Skip to content

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

15.2 KB
Raw Blame
use super::*;
use crate::ProductMesh;
use crate::job::{ReflectionBody, ReflectionMode, ReflectionOptions};
use solidcraft_geom::Mesh;
use std::sync::Arc;

fn visible_second_body_fixture(spatial: u8, samples: u8) -> ImageTask {
    let mut source = scene();
    source.meshes[0].surface = Some(OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 1.0, 1.0, 1.5).unwrap());
    source.meshes[0].mesh = Arc::new(Mesh {
        positions: vec![
            Vec3::new(-100.0, -100.0, -100.0),
            Vec3::new(100.0, -100.0, -100.0),
            Vec3::new(100.0, 100.0, 100.0),
            Vec3::new(-100.0, 100.0, 100.0),
        ],
        normals: vec![Vec3::new(0.0, -1.0, 1.0); 4],
        triangles: vec![[0, 1, 2], [0, 2, 3]],
        tri_face: vec![0, 0],
        ..Default::default()
    });
    // Camera and reflector lie INSIDE this separate inward-facing box. A
    // primary hits the nearer reflector first; every valid secondary leaving
    // it eventually intersects body1. No emitter or test-only transport hook.
    let mut target = Mesh::default();
    for normal in [Vec3::X, -Vec3::X, Vec3::Y, -Vec3::Y, Vec3::Z, -Vec3::Z] {
        let tangent = if normal.x == 0.0 { Vec3::X } else { Vec3::Y };
        let bitangent = normal.cross(tangent);
        let center = -normal * 10_000.0;
        let first = target.positions.len() as u32;
        for (x, y) in [(-1.0, -1.0), (1.0, -1.0), (1.0, 1.0), (-1.0, 1.0)] {
            target.positions.push(center + tangent * (x * 10_000.0) + bitangent * (y * 10_000.0));
            target.normals.push(normal);
        }
        target.triangles.extend([[first, first + 1, first + 2], [first, first + 2, first + 3]]);
        target.tri_face.extend([0, 0]);
    }
    source.meshes[1].mesh = Arc::new(target);
    source.bounds = source.meshes.iter().fold(solidcraft_geom::Aabb3::EMPTY, |bounds, body| bounds.union(&body.mesh.bounds()));
    let mut req = request(Some(reflection_options(ReflectionMode::RoughSpecular)));
    req.width = 1;
    req.height = 1;
    // Perspective near clipping starts inside the box. Orthographic near
    // clipping includes geometry behind the eye and starts outside this box.
    // tan(0.25) < 1/3: the whole film hits |x|, |y|=|z| < 25, within
    // the reflector extent100 and before any target box wall10000.
    req.camera.fov = 0.5;
    let options = req.raytrace.as_mut().unwrap();
    options.primary_samples = spatial;
    options.reflections.as_mut().unwrap().samples = samples;
    options.reflections.as_mut().unwrap().max_bounces = 1;
    let options = options.clone();
    ImageTask::new(source, req, CancelToken::default(), options).unwrap()
}

#[test]
fn visible_transport_hits_a_real_second_body_and_completes_all_spatial_reflection_attempts() {
    for spatial in [1_u8, 4, 16] {
        for samples in [1_u8, 4, 16, 64] {
            let mut task = visible_second_body_fixture(spatial, samples);
            let mut primary_attempts = std::collections::BTreeSet::new();
            let mut secondary_spawns = std::collections::BTreeSet::new();
            let mut second_body_hits = std::collections::BTreeSet::new();
            let expected = usize::from(spatial) * usize::from(samples);
            let mut completed = None;
            for _ in 0..200_000 {
                let absent = task.pending.is_none();
                let work = task.work.used();
                let poll = task.step(1).unwrap();
                assert!(task.work.used() - work <= 4);
                if let Some(pending) = task.pending.as_ref() {
                    let key = (task.spatial, task.sample);
                    if absent && pending.bounce == 0 {
                        assert!(primary_attempts.insert(key), "a fixed S,R attempt was retried");
                    }
                    if pending.bounce == 0
                        && let Some(hit) = pending.hit
                    {
                        assert_eq!(task.looks[hit.primitive_index].body_index, 0, "every primary must reach the selected reflector first");
                    }
                    if pending.bounce == 1 {
                        secondary_spawns.insert(key);
                        if let Some(hit) = pending.hit {
                            assert_eq!(task.looks[hit.primitive_index].body_index, 1, "spawn alone is insufficient: resolve body identity");
                            second_body_hits.insert(key);
                        }
                    }
                }
                if !task.pixels.is_empty() {
                    assert_eq!(primary_attempts.len(), expected, "pixel published before every S*R attempt, including nulls");
                }
                if let TaskPoll::Complete(png) = poll {
                    completed = Some(png);
                    break;
                }
            }
            assert_eq!(task.pixel, 1);
            assert!(task.done);
            assert_eq!(primary_attempts.len(), expected);
            assert_eq!(second_body_hits, secondary_spawns, "every accepted secondary must finish tracing its actual second body");
            if spatial == 1 {
                assert!(!second_body_hits.is_empty(), "the centre fixture must actually hit another body");
                if samples == 64 {
                    assert!(secondary_spawns.len() < expected, "unit roughness must also exercise null attempts without retry/renormalization");
                }
            }
            let decoded = ::image::load_from_memory(&completed.expect("bounded full S*R traversal did not complete")).unwrap().to_rgba8();
            assert_eq!(decoded.dimensions(), (1, 1));
            assert_eq!(decoded.get_pixel(0, 0).0[3], 255);
        }
    }
}

#[test]
fn visible_rough_transport_keeps_cancellation_and_work_caps_at_sample_count_extremes() {
    for samples in [1, 4, 16, 64] {
        for cancel_now in [false, true] {
            let mut reflection = reflection_options(ReflectionMode::RoughSpecular);
            reflection.samples = samples;
            let request = request(Some(reflection));
            let options = request.raytrace.clone().unwrap();
            let cancel = CancelToken::default();
            let mut task = ImageTask::new(scene(), request, cancel.clone(), options).unwrap();
            let mut reached = false;
            for _ in 0..100_000 {
                let before = task.work.used();
                assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
                assert!(task.work.used() - before <= 4, "public quantum expanded");
                if task.pending.as_ref().is_some_and(|p| p.bounce > 0) {
                    reached = true;
                    break;
                }
            }
            assert!(reached, "actual VNDF rough continuation was not exercised");
            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 scene() -> ProductScene {
    fn quad(name: &str, positions: Vec<Vec3>, normal: Vec3, color: [u8; 3], surface: Option<OpaqueSurface>) -> ProductMesh {
        ProductMesh {
            transmission: None,
            name: name.into(),
            mesh: Arc::new(Mesh {
                positions,
                normals: vec![normal; 4],
                triangles: vec![[0, 1, 2], [0, 2, 3]],
                tri_face: vec![0, 0],
                ..Default::default()
            }),
            color,
            opacity: 1.0,
            surface,
            faces: Vec::new(),
        }
    }
    let mirror = quad(
        "Mirror",
        vec![Vec3::new(-20.0, -20.0, -20.0), Vec3::new(20.0, -20.0, -20.0), Vec3::new(20.0, 20.0, 20.0), Vec3::new(-20.0, 20.0, 20.0)],
        Vec3::new(0.0, -1.0, 1.0),
        [255; 3],
        Some(OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 1.0, 0.2, 1.5).unwrap()),
    );
    let object = quad(
        "Orange target",
        vec![Vec3::new(-8.0, -8.0, 10.0), Vec3::new(-8.0, 8.0, 10.0), Vec3::new(8.0, 8.0, 10.0), Vec3::new(8.0, -8.0, 10.0)],
        -Vec3::Z,
        [240, 80, 20],
        None,
    );
    let meshes = vec![mirror, object];
    let bounds = meshes.iter().fold(solidcraft_geom::Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
    ProductScene { meshes, bounds }
}
fn request(reflections: Option<ReflectionOptions>) -> ImageRequest {
    let mut camera = crate::Camera { distance: 50.0, ..Default::default() };
    camera.set_view(crate::StandardView::Front);
    ImageRequest {
        studio_weights: None,
        environment: None,
        textures: None,
        integrator: job::Integrator::Raytrace,
        raytrace: Some(RaytraceOptions {
            reflections,
            shadows: false,
            lights: Some(vec![job::DirectionalLightOptions { direction: [0.0, 0.0, -1.0], color: [1.0; 3], intensity: 2.0 }]),
            ..Default::default()
        }),
        camera,
        width: 9,
        height: 9,
        background: [13, 27, 41],
        transparent_background: false,
    }
}
fn reflection_options(mode: ReflectionMode) -> ReflectionOptions {
    ReflectionOptions { bodies: vec![ReflectionBody { body: "Mirror".into(), mode }], max_bounces: 2, samples: 16 }
}
fn render(request: ImageRequest) -> Vec<u8> {
    let options = request.raytrace.clone().unwrap();
    let mut task = ImageTask::new(scene(), request, CancelToken::default(), options).unwrap();
    for _ in 0..200_000 {
        if let TaskPoll::Complete(png) = task.step(16384).unwrap() {
            return png;
        }
    }
    panic!("bounded reflection fixture did not complete");
}
#[test]
fn mirror_png_contains_other_body_and_rough_transport_is_reproducible() {
    let baseline = ::image::load_from_memory(&render(request(None))).unwrap().to_rgba8();
    let mirrored = ::image::load_from_memory(&render(request(Some(reflection_options(ReflectionMode::Mirror))))).unwrap().to_rgba8();
    let b = baseline.get_pixel(4, 4).0;
    let p = mirrored.get_pixel(4, 4).0;
    assert!(p[0] > p[1] && p[1] > p[2], "actual orange object must be reflected: {p:?}");
    assert_ne!(p, b, "reflection must change the scene image, not only metadata");
    let rough = request(Some(reflection_options(ReflectionMode::RoughSpecular)));
    assert_eq!(render(rough.clone()), render(rough));
}
#[test]
fn explicit_empty_overrides_preserve_baseline_bytes_and_validate_names_atomically() {
    assert_eq!(render(request(None)), render(request(Some(ReflectionOptions::default()))));
    let mut options = reflection_options(ReflectionMode::Mirror);
    options.bodies[0].body = "missing".into();
    let request = request(Some(options));
    assert_eq!(admit(&scene(), &request, request.raytrace.as_ref().unwrap()).err().unwrap().code, ErrorCode::InvalidRequest);
    let hostile = ReflectionOptions { bodies: Vec::with_capacity(65), ..ReflectionOptions::default() };
    assert!(hostile.validate().is_err());
}
#[test]
fn reflection_cancel_and_work_exhaustion_never_publish_partial_frame() {
    for mode in [ReflectionMode::Mirror, ReflectionMode::RoughSpecular] {
        for cancel_now in [false, true] {
            let request = request(Some(reflection_options(mode)));
            let options = request.raytrace.clone().unwrap();
            let cancel = CancelToken::default();
            let mut task = ImageTask::new(scene(), request, cancel.clone(), options).unwrap();
            let mut reached = false;
            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) {
                    reached = true;
                    break;
                }
            }
            assert!(reached);
            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);
            }
        }
    }
}
#[test]
fn prepared_hit_preserves_original_winding_identity_and_never_certifies_glass() {
    let source = scene();
    let primitive = &source.meshes[0];
    let indices = primitive.mesh.triangles[0];
    let vertices = indices.map(|i| primitive.mesh.positions[i as usize]);
    let triangle = Triangle::new(vertices).unwrap();
    let ray = Ray::new(Vec3::new(2.0, -50.0, 0.0), Vec3::Y, 0.0, 100.0).unwrap();
    let geometry = triangle.intersect(&ray).unwrap();
    let cancel = CancelToken::default();
    let mut builder = BvhBuilder::new(vec![triangle], limits(job::CpuBudget::Compact), &cancel).unwrap();
    while !builder.step(1, &cancel).unwrap().complete {}
    let bvh = builder.finish().unwrap();
    let primitives = [PreparedPrimitive {
        has_face_override: false,
        body_index: 0,
        face: Some(0),
        vertices,
        normals: [geometry.geometric_normal; 3],
        surface: primitive.surface.unwrap(),
    }];
    let prepared = PreparedScene { bvh: &bvh, primitives: &primitives, source: &source };
    let shared = prepared.resolve_hit(ray, super::super::Hit { primitive_index: 0, geometry }).unwrap();
    assert_eq!(shared.body_name, "Mirror");
    assert_eq!(shared.geometric_normal, geometry.geometric_normal);
    assert_eq!(shared.front_face, geometry.front_face);
    assert_eq!(prepared.boundary_status(0), super::super::prepared::BoundaryStatus::Unknown);
}
#[test]
fn shared_spawn_excludes_signed_zero_self_hit_without_skipping_thin_blockers() {
    for x in [0.0, 1e12 - 100.0] {
        let vertices = [Vec3::new(x, 0.0, 0.0), Vec3::new(x + 20.0, 0.0, 0.0), Vec3::new(x, 20.0, 0.0)];
        let triangle = Triangle::new(vertices).unwrap();
        let ray = Ray::new(Vec3::new(x + 5.0, 5.0, 10.0), -Vec3::Z, 0.0, 20.0).unwrap();
        let geometry = triangle.intersect(&ray).unwrap();
        let primitive = PreparedPrimitive {
            has_face_override: false,
            body_index: 0,
            face: Some(0),
            vertices,
            normals: [Vec3::Z; 3],
            surface: OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 0.0, 0.7, 1.5).unwrap(),
        };
        let source = ProductScene {
            meshes: vec![ProductMesh {
                transmission: None,
                name: "Plane".into(),
                mesh: Arc::new(Mesh::default()),
                color: [255; 3],
                opacity: 1.0,
                surface: None,
                faces: Vec::new(),
            }],
            bounds: Default::default(),
        };
        let cancel = CancelToken::default();
        let mut builder = BvhBuilder::new(vec![triangle], limits(job::CpuBudget::Compact), &cancel).unwrap();
        while !builder.step(1, &cancel).unwrap().complete {}
        let bvh = builder.finish().unwrap();
        let primitives = [primitive];
        let prepared = PreparedScene { bvh: &bvh, primitives: &primitives, source: &source };
        let hit = prepared.resolve_hit(ray, super::super::Hit { primitive_index: 0, geometry }).unwrap();
        let secondary = hit.spawn(Vec3::Z).unwrap();
        assert!(secondary.interval()[0] > 0.0);
        assert!(triangle.intersect(&secondary).is_none());
        assert!(Triangle::new(vertices.map(|v| v + Vec3::Z * 0.005)).unwrap().intersect(&secondary).is_some());
    }
}