SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
use super::*;
use crate::{Camera, ProductMesh, StandardView};
use solidcraft_geom::{Aabb3, Mesh};
use std::sync::Arc;
fn request() -> ImageRequest {
let mut camera = Camera { distance: 50.0, ..Default::default() };
camera.set_view(StandardView::Front);
ImageRequest {
studio_weights: None,
environment: None,
textures: None,
integrator: Default::default(),
raytrace: None,
camera,
width: 64,
height: 64,
background: [20, 40, 60],
transparent_background: true,
}
}
#[test]
fn render_lights_raster_mute_is_captured_in_request_and_darkens_only_the_product() {
let part = scene(vec![square("part", [200, 180, 160], 1.0, Vec3::ZERO)]);
let mut input = request();
input.transparent_background = false;
let normal = finish(ImageTask::new(part.clone(), input.clone(), super::CancelToken::default()).unwrap());
input.studio_weights = Some([0.0; 3]);
let dark = finish(ImageTask::new(part, input, super::CancelToken::default()).unwrap());
assert_ne!(normal, dark);
let image = image::load_from_memory(&dark).unwrap().to_rgba8();
assert_eq!(image.get_pixel(32, 32).0, [0, 0, 0, 255]);
assert_eq!(image.get_pixel(0, 0).0, [20, 40, 60, 255]);
}
fn square(name: &str, colour: [u8; 3], opacity: f64, offset: Vec3) -> ProductMesh {
let mesh = Mesh {
positions: vec![
Vec3::new(-10.0, 0.0, -10.0) + offset,
Vec3::new(10.0, 0.0, -10.0) + offset,
Vec3::new(10.0, 0.0, 10.0) + offset,
Vec3::new(-10.0, 0.0, 10.0) + offset,
],
normals: vec![Vec3::new(0.0, -1.0, 0.0); 4],
triangles: vec![[0, 1, 2], [0, 2, 3]],
tri_face: vec![0, 1],
..Default::default()
};
ProductMesh { name: name.into(), mesh: Arc::new(mesh), color: colour, opacity, surface: None, transmission: None, faces: Vec::new() }
}
fn scene(meshes: Vec<ProductMesh>) -> ProductScene {
let bounds = meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
ProductScene { meshes, bounds }
}
fn finish(mut task: ImageTask) -> Vec<u8> {
for _ in 0..100_000 {
match task.step(4096).unwrap() {
TaskPoll::Complete(png) => return png,
TaskPoll::Pending(p) => assert!(p.done <= p.total, "{p:?}"),
}
}
panic!("bounded fixture did not finish");
}
#[test]
fn transparent_png_has_straight_srgb_colour_without_a_shared_edge_seam() {
let scene = scene(vec![square("Glass", [220, 40, 20], 0.5, Vec3::ZERO)]);
let png = finish(ImageTask::new(scene, request(), CancelToken::default()).unwrap());
let image = image::load_from_memory(&png).unwrap().to_rgba8();
assert_eq!(image.get_pixel(0, 0).0, [0; 4]);
for (x, y) in [(32, 32), (31, 31), (30, 32), (32, 30)] {
let p = image.get_pixel(x, y).0;
assert!((i16::from(p[3]) - 128).abs() <= 1, "a shared diagonal must not double-blend: {p:?}");
assert!(p[0] > 180 && p[0] > p[1] + 60, "RGB is straight, not multiplied by 0.5: {p:?}");
}
let reader = png::Decoder::new(std::io::Cursor::new(png)).read_info().unwrap();
assert_eq!(reader.info().srgb, Some(png::SrgbRenderingIntent::Perceptual));
}
#[test]
fn glass_is_sorted_back_to_front_independently_of_body_order() {
let request = request();
let far = square("Far", [240, 20, 20], 0.5, request.camera.back() * -5.0);
let near = square("Near", [20, 20, 240], 0.5, request.camera.back() * 5.0);
let a = finish(ImageTask::new(scene(vec![far.clone(), near.clone()]), request.clone(), CancelToken::default()).unwrap());
let b = finish(ImageTask::new(scene(vec![near, far]), request, CancelToken::default()).unwrap());
assert_eq!(a, b);
let image = image::load_from_memory(&a).unwrap().to_rgba8();
let p = image.get_pixel(32, 32).0;
assert!((i16::from(p[3]) - 192).abs() <= 1, "two half-transparent layers: {p:?}");
assert!(p[2] > p[0] + 30, "the near blue layer contributes more: {p:?}");
}
#[test]
fn physical_transmission_keeps_the_exact_scalar_cpu_preview() {
let original = square("Glass", [80, 180, 140], 0.25, Vec3::ZERO);
let mut glass = original.clone();
glass.surface = Some(crate::surface::OpaqueSurface::new(Vec3::new(0.2, 0.4, 0.3), 0.0, 0.1, 1.5).unwrap());
glass.transmission = Some(crate::transmission::Transmission::new(Vec3::new(-0.7_f64.ln(), -0.9_f64.ln(), 0.0) / 10.0, None).unwrap());
let expected = finish(ImageTask::new(scene(vec![original]), request(), CancelToken::default()).unwrap());
let actual = finish(ImageTask::new(scene(vec![glass]), request(), CancelToken::default()).unwrap());
assert_eq!(actual, expected);
}
#[test]
fn cpu_raytrace_refuses_physical_transmission_before_preparation() {
let mut glass = square("Glass", [200; 3], 1.0, Vec3::ZERO);
glass.transmission = Some(crate::transmission::Transmission::new(Vec3::ZERO, Some(1.0)).unwrap());
let mut input = request();
input.integrator = super::super::Integrator::Raytrace;
input.transparent_background = false;
let error = admit(&scene(vec![glass]), &input).unwrap_err();
assert_eq!(error.code, ErrorCode::InvalidRequest);
assert!(error.message.contains("physical transmission"));
}
#[test]
fn cancellation_is_observed_during_preparation_sort_pixels_and_encoding() {
for stage in [Stage::Looks, Stage::Prepare, Stage::Sort, Stage::Clear, Stage::Glass, Stage::Downsample, Stage::Encode] {
let cancel = CancelToken::default();
let mut task = ImageTask::new(scene(vec![square("Glass", [40, 180, 100], 0.4, Vec3::ZERO)]), request(), cancel.clone()).unwrap();
let mut reached = false;
for _ in 0..100_000 {
if task.stage == stage {
reached = true;
break;
}
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
}
assert!(reached);
cancel.cancel();
assert_eq!(task.step(4096).err().unwrap().code, ErrorCode::Cancelled);
}
}
#[test]
fn encoding_yields_between_rows_and_completed_result_is_consumed_once() {
let mut task = ImageTask::new(scene(Vec::new()), request(), CancelToken::default()).unwrap();
while task.stage != Stage::Encode {
assert!(matches!(task.step(64).unwrap(), TaskPoll::Pending(_)));
}
let before = task.encoder.as_ref().unwrap().row();
assert!(matches!(task.step(usize::MAX).unwrap(), TaskPoll::Pending(_)));
assert!(task.encoder.as_ref().unwrap().row() - before <= 4);
loop {
if let TaskPoll::Complete(bytes) = task.step(4096).unwrap() {
assert_eq!(image::load_from_memory(&bytes).unwrap().width(), 64);
break;
}
}
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::NotCompleted);
}
#[test]
fn invalid_sizes_indices_opacity_and_large_work_lists_fail_without_a_frame() {
let body = square("Product", [100, 120, 140], 1.0, Vec3::ZERO);
let mut bad_request = request();
bad_request.width = u32::MAX;
assert!(ImageTask::new(scene(vec![body.clone()]), bad_request, CancelToken::default()).is_err());
for bad in [0, 1] {
let mut body = body.clone();
if bad == 0 {
Arc::make_mut(&mut body.mesh).triangles[0][0] = u32::MAX;
} else {
body.faces.push(FaceAppearance { face: 0, color: [0; 3], opacity: f64::NAN, surface: None, transmission: None });
}
let error = ImageTask::new(scene(vec![body]), request(), CancelToken::default()).err().unwrap();
assert_eq!(error.code, ErrorCode::InvalidScene);
}
let mut body = body;
Arc::make_mut(&mut body.mesh).triangles.resize(MAX_TRIANGLES as usize + 1, [0, 1, 2]);
assert_eq!(ImageTask::new(scene(vec![body]), request(), CancelToken::default()).err().unwrap().code, ErrorCode::LimitExceeded);
assert_eq!(std::mem::size_of::<Draw>(), 16, "admission accounts for each of the three lists");
}
#[test]
fn registered_executor_geometry_admission_excludes_the_cpu_raster_estimate() {
// A library-bounded source: about 120 MiB of face appearances on a small mesh at the
// largest image. Its CPU raster estimate is above 384 MiB at a registered executor's cap.
let count = (120 * 1024 * 1024 / std::mem::size_of::<FaceAppearance>()).min(1_000_000);
let mut body = square("appearances", [200; 3], 1.0, Vec3::ZERO);
body.faces = vec![FaceAppearance { transmission: None, face: 0, color: [200; 3], opacity: 1.0, surface: None }; count];
let source = scene(vec![body]);
let mut r = request();
r.width = 2048;
r.height = 2048;
let cpu = admit_raster(admit_source(&source, &r, 1_048_576).unwrap()).unwrap_err();
assert_eq!(cpu.code, ErrorCode::LimitExceeded);
assert!(cpu.message.contains("384 MiB"), "{}", cpu.message);
let geometry = admit_geometry(&source, &r, 1_048_576).unwrap();
assert_eq!((geometry.pixel_scratch_bytes, geometry.preparation_bytes), (0, 0));
assert_eq!(geometry.estimated_total_bytes, geometry.geometry_bytes);
assert_eq!(geometry.face_appearances, count as u64);
// The CPU host itself keeps rejecting the source.
assert_eq!(admit(&source, &r).unwrap_err().code, ErrorCode::LimitExceeded);
}
#[test]
fn admission_rejects_projected_pixel_work_before_starting_a_job() {
let mut body = square("Overlapping glass", [100, 120, 140], 0.55, Vec3::ZERO);
let mesh = Arc::make_mut(&mut body.mesh);
mesh.triangles = vec![[0, 1, 2]; 1024];
mesh.tri_face = vec![0; 1024];
let scene = scene(vec![body]);
let request = ImageRequest { width: 512, height: 512, ..request() };
let error = admit(&scene, &request).expect_err("preflight must reject the same pixel-work limit as the rasterizer");
assert_eq!(error.code, ErrorCode::LimitExceeded);
assert!(error.message.contains("pixel tests"));
let request = ImageRequest { width: 64, height: 64, ..request };
let admission = admit(&scene, &request).unwrap();
assert!(admission.projected_pixel_tests.unwrap() > 0);
assert!(admission.projected_pixel_tests.unwrap() <= MAX_PIXEL_TESTS);
let png = finish(ImageTask::new(scene, request, CancelToken::default()).unwrap());
assert_eq!(image::load_from_memory(&png).unwrap().width(), 64);
}
#[test]
fn pixel_work_admission_includes_the_limit_and_uses_clipped_sample_bounds() {
let mut body = square("Full viewport", [100; 3], 1.0, Vec3::ZERO);
let mesh = Arc::make_mut(&mut body.mesh);
// Each triangle's bounds cover all 200 * 200 supersampled pixels.
mesh.triangles = vec![[0, 1, 2]; 3200];
mesh.tri_face = vec![0; 3200];
let mut request = ImageRequest { width: 100, height: 100, ..request() };
request.camera.distance = 1.0;
request.camera.fov = 0.0;
let mut scene = scene(vec![body]);
assert_eq!(admit(&scene, &request).unwrap().projected_pixel_tests, Some(128_000_000));
let mut task = ImageTask::new(scene.clone(), request.clone(), CancelToken::default()).unwrap();
while task.stage != Stage::Clear {
task.step(1).unwrap();
}
assert_eq!(task.pixel_tests, 128_000_000);
Arc::make_mut(&mut scene.meshes[0].mesh).triangles.push([0, 1, 2]);
assert_eq!(admit(&scene, &request).unwrap_err().code, ErrorCode::LimitExceeded);
// Registered executors budget their own work, independently of the raster projection.
let geometry = admit_geometry(&scene, &request, MAX_TRIANGLES).unwrap();
assert_eq!(geometry.projected_pixel_tests, None);
assert!(serde_json::to_value(geometry).unwrap().get("projected_pixel_tests").is_none());
}
#[test]
fn pixel_work_ignores_invisible_triangles_and_respects_the_last_face_override() {
let mut body = square("Hidden", [100; 3], 0.0, Vec3::ZERO);
let request = request();
assert_eq!(admit(&scene(vec![body.clone()]), &request).unwrap().projected_pixel_tests, Some(0));
body.faces.push(FaceAppearance { face: 0, color: [100; 3], opacity: 0.55, surface: None, transmission: None });
assert!(admit(&scene(vec![body.clone()]), &request).unwrap().projected_pixel_tests.unwrap() > 0);
body.faces.push(FaceAppearance { face: 0, color: [100; 3], opacity: 0.0, surface: None, transmission: None });
assert_eq!(admit(&scene(vec![body]), &request).unwrap().projected_pixel_tests, Some(0));
let offscreen = square("Offscreen", [100; 3], 1.0, Vec3::new(10_000.0, 0.0, 0.0));
assert_eq!(admit(&scene(vec![offscreen]), &request).unwrap().projected_pixel_tests, Some(0));
let mut degenerate = square("Degenerate", [100; 3], 1.0, Vec3::ZERO);
Arc::make_mut(&mut degenerate.mesh).triangles = vec![[0, 0, 0]];
assert_eq!(admit(&scene(vec![degenerate]), &request).unwrap().projected_pixel_tests, Some(0));
}