SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
use super::*;
use solidcraft_geom::Aabb3;
fn emission_fixture(reverse: bool) -> (ProductScene, ImageRequest, RaytraceOptions) {
use std::sync::Arc;
let mut meshes = Vec::new();
for (name, lo, hi) in [("emitter", -20.0, 0.0), ("receiver", 0.0, 20.0)] {
let mesh = solidcraft_geom::Mesh {
positions: vec![Vec3::new(lo, -10.0, 0.0), Vec3::new(hi, -10.0, 0.0), Vec3::new(hi, 10.0, 0.0), Vec3::new(lo, 10.0, 0.0)],
normals: vec![Vec3::Z; 4],
triangles: if reverse { vec![[0, 2, 1], [0, 3, 2]] } else { vec![[0, 1, 2], [0, 2, 3]] },
tri_face: vec![0; 2],
..Default::default()
};
meshes.push(crate::ProductMesh {
transmission: None,
name: name.into(),
mesh: Arc::new(mesh),
color: [255; 3],
opacity: 1.0,
surface: None,
faces: Vec::new(),
});
}
let bounds = meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
let mut request = request();
request.width = 2;
request.height = 1;
request.camera.distance = 25.0;
request.camera.fov = 0.0;
request.camera.set_view(crate::StandardView::Top);
let options = RaytraceOptions {
lights: Some(Vec::new()),
emissions: Some(vec![job::SurfaceEmission {
body_index: 0,
body: "emitter".into(),
color: [0.25, 0.5, 1.0],
strength: 1.0,
sides: job::EmissionSides::Front,
}]),
..Default::default()
};
(ProductScene { meshes, bounds }, request, options)
}
fn emission_png(scene: ProductScene, mut request: ImageRequest, options: RaytraceOptions) -> Vec<u8> {
request.raytrace = Some(options.clone());
let mut task = ImageTask::new(scene, request, CancelToken::default(), options).unwrap();
for _ in 0..10_000 {
if let TaskPoll::Complete(png) = task.step(16384).unwrap() {
return png;
}
}
panic!("emission fixture did not complete");
}
#[test]
fn emission_actual_png_adds_linear_radiance_once_and_never_lights_neighbor() {
let (scene, request, mut options) = emission_fixture(false);
for ev in [0.0, 1.0] {
options.exposure_ev = ev;
let image = ::image::load_from_memory(&emission_png(scene.clone(), request.clone(), options.clone())).unwrap().to_rgba8();
let expected = [0.25, 0.5, 1.0].map(|c| {
let v = c * 2.0_f64.powf(ev);
encode8(v / (1.0 + v))
});
assert_eq!(image.get_pixel(0, 0).0, [expected[0], expected[1], expected[2], 255]);
assert_eq!(image.get_pixel(1, 0).0, [0, 0, 0, 255]);
}
}
#[test]
fn emission_zero_default_png_equivalence_and_geometric_sidedness() {
let (scene, request, mut options) = emission_fixture(false);
options.emissions.as_mut().unwrap()[0].strength = 0.0;
let zero = emission_png(scene.clone(), request.clone(), options.clone());
options.emissions = None;
assert_eq!(zero, emission_png(scene, request, options));
let (scene, request, mut options) = emission_fixture(true);
let image = ::image::load_from_memory(&emission_png(scene.clone(), request.clone(), options.clone())).unwrap().to_rgba8();
assert_eq!(image.get_pixel(0, 0).0, [0, 0, 0, 255], "shading normals cannot turn a back face into an emitter");
options.emissions.as_mut().unwrap()[0].sides = job::EmissionSides::Both;
let image = ::image::load_from_memory(&emission_png(scene, request, options)).unwrap().to_rgba8();
assert!(image.get_pixel(0, 0).0[0] > 0);
}
#[test]
fn emission_stale_duplicate_and_capacity_targets_refuse_before_work() {
let (scene, mut request, mut options) = emission_fixture(false);
options.emissions.as_mut().unwrap()[0].body = "renamed".into();
request.raytrace = Some(options.clone());
assert_eq!(admit(&scene, &request, &options).unwrap_err().code, ErrorCode::InvalidScene);
let (_, _, mut options) = emission_fixture(false);
let first = options.emissions.as_ref().unwrap()[0].clone();
options.emissions.as_mut().unwrap().push(first);
assert!(options.validate().is_err());
options.emissions = Some(Vec::with_capacity(64));
assert!(options.validate().is_err());
}
#[test]
fn emission_survives_face_reflectance_override_without_changing_captured_geometry() {
let (mut scene, request, options) = emission_fixture(false);
let original = scene.meshes[0].mesh.clone();
let baseline = emission_png(scene.clone(), request.clone(), options.clone());
scene.meshes[0].faces.push(crate::FaceAppearance { transmission: None, face: 0, color: [0; 3], opacity: 1.0, surface: None });
assert_eq!(baseline, emission_png(scene.clone(), request, options));
assert!(std::sync::Arc::ptr_eq(&original, &scene.meshes[0].mesh));
assert_eq!(scene.meshes[0].faces[0].color, [0; 3]);
}
#[test]
fn emission_scan_observes_cancel_and_exhausts_shared_work_without_png() {
let (scene, mut request, options) = emission_fixture(false);
request.raytrace = Some(options.clone());
let cancel = CancelToken::default();
let mut task = ImageTask::new(scene, request, cancel.clone(), options).unwrap();
for _ in 0..10_000 {
if task.pending.as_ref().is_some_and(|p| p.hit.is_some() && p.light == task.lights.lights().len() && p.emission_cursor == 0) {
task.work.limit = task.work.used() + 1;
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::LimitExceeded);
assert!(!task.done);
assert!(task.pixels.is_empty());
cancel.cancel();
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
return;
}
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
}
panic!("fixture never reached shading");
}
#[test]
fn thirty_two_emission_bindings_resume_with_four_work_units_and_cancel_without_publication() {
for cancel_midway in [false, true] {
let (mut scene, mut request, mut options) = emission_fixture(false);
while scene.meshes.len() < 32 {
let mut mesh = scene.meshes[1].clone();
mesh.name = format!("receiver {}", scene.meshes.len());
scene.meshes.push(mesh);
}
let base = options.emissions.as_ref().unwrap()[0].clone();
let mut values = Vec::with_capacity(32);
for index in (1..32).chain(std::iter::once(0)) {
values.push(job::SurfaceEmission { body_index: index, body: scene.meshes[index].name.clone(), ..base.clone() });
}
options.emissions = Some(values);
request.raytrace = Some(options.clone());
let cancel = CancelToken::default();
let mut task = ImageTask::new(scene, request, cancel.clone(), options).unwrap();
for _ in 0..100_000 {
if task.pending.as_ref().is_some_and(|p| p.hit.is_some() && p.light == task.lights.lights().len() && p.emission_cursor == 0) {
break;
}
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
}
assert_eq!(task.pending.as_ref().unwrap().emission_cursor, 0);
assert_eq!(task.pending.as_ref().unwrap().radiance, Vec3::ZERO);
for expected_cursor in (4..=32).step_by(4) {
let before = task.work.used();
assert!(matches!(task.step(16384).unwrap(), TaskPoll::Pending(_)));
assert_eq!(task.work.used() - before, 4);
let pending = task.pending.as_ref().unwrap();
assert_eq!(pending.emission_cursor, expected_cursor);
assert_eq!(pending.radiance, if expected_cursor == 32 { Vec3::new(0.25, 0.5, 1.0) } else { Vec3::ZERO });
assert!(task.pixels.is_empty());
if cancel_midway && expected_cursor == 16 {
cancel.cancel();
assert_eq!(task.step(4).err().unwrap().code, ErrorCode::Cancelled);
assert_eq!(task.work.used() - before, 4);
assert!(task.pixels.is_empty());
break;
}
}
if !cancel_midway {
let before = task.work.used();
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
assert_eq!(task.work.used() - before, 1);
assert_eq!(task.pixel, 1);
assert_eq!(task.pixels, [encode8(0.25 / 1.25), encode8(0.5 / 1.5), encode8(0.5), 255]);
}
}
}
fn request() -> ImageRequest {
ImageRequest {
studio_weights: None,
environment: None,
textures: None,
integrator: job::Integrator::Raytrace,
raytrace: None,
camera: Default::default(),
width: 8,
height: 8,
background: [10, 20, 30],
transparent_background: false,
}
}
#[test]
fn image_work_exhaustion_is_typed_and_never_publishes_partial_png() {
let mut task =
ImageTask::new(ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY }, request(), CancelToken::default(), Default::default()).unwrap();
task.work = WorkBudget::new(2).unwrap();
let mut previous = 0;
for _ in 0..20 {
match task.step(1) {
Ok(TaskPoll::Pending(_)) => {
assert!(task.work.used() >= previous);
previous = task.work.used();
}
Ok(TaskPoll::Complete(_)) => panic!("exhausted task published a frame"),
Err(e) => {
assert_eq!(e.code, ErrorCode::LimitExceeded);
assert_eq!(task.work.used(), 2);
return;
}
}
}
panic!("tiny budget did not stop image");
}
#[test]
fn thin_shadow_occluder_survives_large_unrelated_translation() {
for x in [0.0, 1.0e12 - 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 receiver = Triangle::new(vertices).unwrap();
let primary = Ray::new(Vec3::new(x + 5.0, 5.0, 10.0), -Vec3::Z, 0.0, 20.0).unwrap();
let geometry = receiver.intersect(&primary).unwrap();
let shadow = shadow_ray(primary, super::super::Hit { primitive_index: 0, geometry }, Vec3::Z, vertices).unwrap();
assert!(shadow.interval()[0] > 0.0, "secondary rays exclude signed-zero distance after underflow");
assert!(receiver.intersect(&shadow).is_none(), "self-shadow at translation {x}");
let occluder = Triangle::new(vertices.map(|v| v + Vec3::Z * 0.005)).unwrap();
assert!(occluder.intersect(&shadow).is_some(), "thin blocker was skipped at translation {x}");
}
}
#[test]
fn primary_intervals_follow_camera_clip_planes_for_both_projections_and_up_axes() {
for fov in [0.0, 0.7] {
for up in [crate::UpAxis::Z, crate::UpAxis::Y] {
let mut request = request();
request.camera.fov = fov;
request.camera.up = up;
let clip = request.camera.clip(20.0);
let ray = primary_ray(&request, 4.0, 4.0, clip).unwrap();
let forward = -request.camera.back();
let near_depth = (ray.origin() - request.camera.eye()).dot(forward);
let far_depth = (ray.at(ray.interval()[1]).unwrap() - request.camera.eye()).dot(forward);
assert!((near_depth - clip.0).abs() < 1e-9);
assert!((far_depth - clip.1).abs() < 1e-9);
}
}
}
#[test]
fn resumable_cursor_matches_original_visibility_and_charges_each_unit() {
let cancel = CancelToken::default();
let triangle = Triangle::new([Vec3::ZERO, Vec3::X, Vec3::Y]).unwrap();
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 ray = Ray::new(Vec3::new(0.2, 0.2, 1.0), -Vec3::Z, 0.0, 2.0).unwrap();
let expected = bvh.closest_hit(&ray, &mut WorkBudget::new(100).unwrap(), &cancel).unwrap();
let mut cursor = TraceCursor::new(ray, false);
let mut work = WorkBudget::new(100).unwrap();
for _ in 0..100 {
let before = work.used();
let result = cursor.step(&bvh, &mut work, &cancel).unwrap();
assert_eq!(work.used(), before + 1);
if let Some(actual) = result {
assert_eq!(actual, expected);
return;
}
}
panic!("cursor failed to finish");
}
#[test]
fn actual_png_has_analytic_lit_and_cast_shadow_pixels() {
use crate::ProductMesh;
use solidcraft_geom::Mesh;
use std::sync::Arc;
fn plane(z: f64, x0: f64, x1: f64) -> ProductMesh {
let mesh = Mesh {
positions: vec![Vec3::new(x0, -10.0, z), Vec3::new(x1, -10.0, z), Vec3::new(x1, 10.0, z), Vec3::new(x0, 10.0, z)],
normals: vec![Vec3::Z; 4],
triangles: vec![[0, 1, 2], [0, 2, 3]],
tri_face: vec![0, 0],
..Default::default()
};
ProductMesh {
transmission: None,
name: format!("plane {z}"),
mesh: Arc::new(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(),
}
}
let meshes = vec![plane(0.0, -20.0, 20.0), plane(5.0, -5.0, 5.0)];
let bounds = meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
let scene = ProductScene { meshes, bounds };
let mut request = request();
request.width = 40;
request.height = 40;
request.camera.distance = 50.0;
request.camera.set_view(crate::StandardView::Top);
let options = RaytraceOptions {
lights: Some(vec![job::DirectionalLightOptions { direction: [-1.0, 0.0, 1.0], color: [1.0; 3], intensity: 1.0 }]),
..Default::default()
};
fn render(scene: ProductScene, mut request: ImageRequest, options: RaytraceOptions) -> ::image::RgbaImage {
request.raytrace = Some(options.clone());
let mut task = ImageTask::new(scene, request, CancelToken::default(), options).unwrap();
for _ in 0..100_000 {
if let TaskPoll::Complete(png) = task.step(16384).unwrap() {
return ::image::load_from_memory(&png).unwrap().to_rgba8();
}
}
panic!("small analytic render did not complete");
}
let shadowed = render(scene.clone(), request.clone(), options.clone());
let lit = render(scene, request, RaytraceOptions { shadows: false, ..options });
// Top view: screen x maps world x, width40 spans[-20,20]. Blocker[-5,5]
// at z5 casts a footprint[0,10] for the light toward(-1,0,+1).
let shadow = shadowed.get_pixel(27, 20).0;
let unshadowed = lit.get_pixel(27, 20).0;
assert_eq!(shadow, [0, 0, 0, 255]);
// White fully rough conductor: F=1, D=1/pi, Smith visibility
// at normal view yields BRDF=1/[2*pi*(1+cosL)].
let cosine = (0.5_f64).sqrt();
let radiance = cosine / (2.0 * std::f64::consts::PI * (1.0 + cosine));
let expected = encode8(radiance / (1.0 + radiance));
assert_eq!(unshadowed, [expected, expected, expected, 255]);
assert_eq!(shadowed.get_pixel(7, 20), lit.get_pixel(7, 20), "unoccluded receiver changes when toggling shadows");
}
fn triangle_task(cancel: CancelToken) -> ImageTask {
use std::sync::Arc;
let mesh = solidcraft_geom::Mesh {
positions: vec![Vec3::new(-20.0, -20.0, 0.0), Vec3::new(20.0, -20.0, 0.0), Vec3::new(0.0, 20.0, 0.0)],
normals: vec![Vec3::Z; 3],
triangles: vec![[0, 1, 2]],
tri_face: vec![0],
..Default::default()
};
let bounds = mesh.bounds();
let scene = ProductScene {
meshes: vec![crate::ProductMesh {
transmission: None,
name: "work fixture".into(),
mesh: Arc::new(mesh),
color: [220; 3],
opacity: 1.0,
surface: None,
faces: Vec::new(),
}],
bounds,
};
let mut request = request();
request.camera.distance = 50.0;
request.camera.set_view(crate::StandardView::Top);
ImageTask::new(scene, request, cancel, Default::default()).unwrap()
}
#[test]
fn face_looks_cost_one_unit_per_triangle_and_the_first_entry_wins() {
use std::sync::Arc;
let (columns, rows) = (8u32, 4u32);
let mut positions = Vec::new();
for y in 0..=rows {
for x in 0..=columns {
positions.push(Vec3::new(f64::from(x) * 5.0 - 20.0, f64::from(y) * 5.0 - 10.0, 0.0));
}
}
let (mut triangles, mut tri_face) = (Vec::new(), Vec::new());
for y in 0..rows {
for x in 0..columns {
let a = y * (columns + 1) + x;
triangles.extend([[a, a + 1, a + columns + 2], [a, a + columns + 2, a + columns + 1]]);
tri_face.extend([y * columns + x; 2]);
}
}
let count = positions.len();
let mesh = solidcraft_geom::Mesh { positions, normals: vec![Vec3::Z; count], triangles, tri_face, ..Default::default() };
let look = |face: u32, color: [u8; 3]| crate::FaceAppearance { face, color, opacity: 1.0, surface: None, transmission: None };
let mut faces: Vec<_> = (0..columns * rows).step_by(2).map(|face| look(face, [face as u8 * 8, 100, 200])).collect();
// Later duplicates never replace the first entry for a face.
faces.extend([look(2, [1, 2, 3]), look(4, [4, 5, 6])]);
let entries = faces.len() as u64;
let bounds = mesh.bounds();
let scene = ProductScene {
meshes: vec![crate::ProductMesh {
transmission: None,
name: "face look fixture".into(),
mesh: Arc::new(mesh),
color: [220; 3],
opacity: 1.0,
surface: None,
faces,
}],
bounds,
};
let mut request = request();
request.camera.distance = 60.0;
request.camera.set_view(crate::StandardView::Top);
let mut task = ImageTask::new(scene, request, CancelToken::default(), Default::default()).unwrap();
let before = task.work.used();
for _ in 0..10_000 {
if task.builder.is_some() || task.bvh.is_some() {
break;
}
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
}
assert!(task.builder.is_some() || task.bvh.is_some(), "preparation did not finish");
let triangles = u64::from(2 * columns * rows);
// One unit per triangle and per face entry, plus the end of the body and the
// hand-over to the BVH builder; scanning the entries per triangle cost ~T*F.
assert_eq!(task.work.used() - before, triangles + entries + 2);
let surface =
|c: [u8; 3]| OpaqueSurface::new(Vec3::new(srgb8_to_linear(c[0]), srgb8_to_linear(c[1]), srgb8_to_linear(c[2])), 0.0, 0.7, 1.5).unwrap();
assert_eq!(task.looks.len() as u64, triangles);
for look in &task.looks {
let face = look.face.unwrap();
let expected = if face % 2 == 0 { [face as u8 * 8, 100, 200] } else { [220; 3] };
assert_eq!(look.surface, surface(expected), "face {face}");
}
}
#[test]
fn build_primary_and_shadows_share_cumulative_work_and_exhaust_atomically() {
let mut task = triangle_task(CancelToken::default());
let mut previous = 0;
let mut built = false;
for _ in 0..10_000 {
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
assert!(task.work.used() >= previous);
previous = task.work.used();
built |= task.builder.is_some();
if task.pending.as_ref().is_some_and(|p| p.hit.is_some() && p.light < task.lights.lights().len()) {
assert!(built);
assert!(task.build_used > 0);
assert!(task.work.used() > task.build_used);
task.work.limit = task.work.used() + 1;
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::LimitExceeded);
return;
}
}
panic!("triangle fixture never reached shadow traversal");
}
#[test]
fn cancellation_is_observed_in_every_ray_image_phase() {
for phase in 0..5 {
let cancel = CancelToken::default();
let mut task = triangle_task(cancel.clone());
let mut reached = false;
for _ in 0..100_000 {
let current = match phase {
0 => task.builder.is_none() && task.bvh.is_none(),
1 => task.builder.is_some(),
2 => task.pending.as_ref().is_some_and(|p| p.hit.is_none()),
3 => task.pending.as_ref().is_some_and(|p| p.hit.is_some()),
_ => task.encoder.is_some(),
};
if current {
reached = true;
break;
}
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
}
assert!(reached, "phase {phase}");
cancel.cancel();
assert_eq!(task.step(4).err().unwrap().code, ErrorCode::Cancelled);
}
}
#[test]
fn runtime_presets_reach_the_lighting_consumer() {
for (runtime, expected) in [
(job::LightingPreset::Neutral, StudioPreset::Neutral),
(job::LightingPreset::WarmCool, StudioPreset::WarmCool),
(job::LightingPreset::KeyRim, StudioPreset::KeyRim),
] {
let options = RaytraceOptions { preset: Some(runtime), ..Default::default() };
assert_eq!(lighting(&options).unwrap(), Lighting::preset(expected).unwrap());
}
let conflict = RaytraceOptions { preset: Some(job::LightingPreset::Neutral), lights: Some(Vec::new()), ..Default::default() };
assert_eq!(lighting(&conflict).err().unwrap().code, ErrorCode::InvalidRequest);
}
#[test]
fn warm_cool_preset_changes_actual_triangle_png() {
fn render(preset: job::LightingPreset) -> Vec<u8> {
let initial = triangle_task(CancelToken::default());
let options = RaytraceOptions { preset: Some(preset), ..Default::default() };
let mut request = initial.request.clone();
request.raytrace = Some(options.clone());
let mut task = ImageTask::new(initial.scene.clone(), request, CancelToken::default(), options).unwrap();
for _ in 0..100_000 {
if let TaskPoll::Complete(bytes) = task.step(16384).unwrap() {
return bytes;
}
}
panic!("preset render did not complete");
}
let neutral = ::image::load_from_memory(&render(job::LightingPreset::Neutral)).unwrap().to_rgba8();
let warm = ::image::load_from_memory(&render(job::LightingPreset::WarmCool)).unwrap().to_rgba8();
assert_ne!(neutral.get_pixel(4, 4), warm.get_pixel(4, 4));
assert_eq!(neutral.get_pixel(0, 0), warm.get_pixel(0, 0), "background must remain independent of lighting preset");
}
#[test]
fn emission_primary_aa_and_reflection_attempts_preserve_single_linear_value() {
for s in [1, 4, 16] {
for r in [1, 4, 16] {
let (mut scene, request, mut options) = emission_fixture(false);
for body in &mut scene.meshes {
let mesh = std::sync::Arc::make_mut(&mut body.mesh);
for p in &mut mesh.positions {
p.x *= 100.0;
p.y *= 100.0;
}
}
scene.bounds = scene.meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
options.primary_samples = s;
options.reflections = Some(job::ReflectionOptions {
bodies: vec![job::ReflectionBody { body: "receiver".into(), mode: job::ReflectionMode::Mirror }],
max_bounces: 1,
samples: r,
});
let image = ::image::load_from_memory(&emission_png(scene, request, options)).unwrap().to_rgba8();
assert_eq!(image.get_pixel(0, 0).0, [encode8(0.25 / 1.25), encode8(0.5 / 1.5), encode8(0.5), 255], "S{s}/R{r}");
assert_eq!(image.get_pixel(1, 0).0, [0, 0, 0, 255], "emission does not illuminate the neighboring reflector");
}
}
}
#[test]
fn emission_and_directional_point_area_terms_share_one_linear_output_transform() {
let (mut scene, mut request, mut options) = emission_fixture(false);
scene.meshes.truncate(1);
let body = &mut scene.meshes[0];
for p in &mut std::sync::Arc::make_mut(&mut body.mesh).positions {
p.x += 10.0;
}
body.surface = Some(OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 1.0, 1.0, 1.5).unwrap());
scene.bounds = body.mesh.bounds();
request.width = 1;
request.height = 1;
options.shadows = false;
options.lights = Some(vec![job::DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 2.0 }]);
options.punctual_lights = Some(vec![job::PunctualLightOptions {
position_mm: [0.0, 0.0, 10.0],
color: [1.0; 3],
intensity: 3.0,
reference_distance_mm: 10.0,
minimum_distance_mm: 0.001,
cone: None,
}]);
options.area_lights = Some(vec![job::RectangleLightOptions {
center_mm: [0.0, 0.0, 10.0],
edge_u_mm: [2.0, 0.0, 0.0],
edge_v_mm: [0.0, -2.0, 0.0],
color: [1.0; 3],
intensity: 5.0,
}]);
options.area_samples = Some(1);
let image = ::image::load_from_memory(&emission_png(scene, request, options)).unwrap().to_rgba8();
// At normal incidence a white fully rough conductor has BRDF 1/(4*pi).
// Point reference distance is 10 mm; the 4 mm² rectangle contributes 5*4/100.
let direct = (2.0 + 3.0 + 5.0 * 4.0 / 100.0) / (4.0 * std::f64::consts::PI);
let expected = [0.25, 0.5, 1.0].map(|e| encode8((e + direct) / (1.0 + e + direct)));
assert_eq!(image.get_pixel(0, 0).0, [expected[0], expected[1], expected[2], 255]);
}
#[test]
fn reflected_hit_adds_surface_emission_with_the_current_path_throughput() {
use std::sync::Arc;
let normal = Vec3::new(1.0, 0.0, 1.0) / 2.0_f64.sqrt();
let mirror_mesh = solidcraft_geom::Mesh {
positions: 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)],
normals: vec![normal; 4],
triangles: vec![[0, 1, 2], [0, 2, 3]],
tri_face: vec![0; 2],
..Default::default()
};
let emitter_mesh = solidcraft_geom::Mesh {
positions: vec![Vec3::new(10.0, -4.0, -2.0), Vec3::new(10.0, -4.0, 2.0), Vec3::new(10.0, 4.0, 2.0), Vec3::new(10.0, 4.0, -2.0)],
normals: vec![-Vec3::X; 4],
triangles: vec![[0, 1, 2], [0, 2, 3]],
tri_face: vec![0; 2],
..Default::default()
};
let base_color = Vec3::new(0.2, 0.5, 0.75);
let meshes = vec![
crate::ProductMesh {
transmission: None,
name: "mirror".into(),
mesh: Arc::new(mirror_mesh),
color: [255; 3],
opacity: 1.0,
surface: Some(OpaqueSurface::new(base_color, 1.0, 0.1, 1.5).unwrap()),
faces: Vec::new(),
},
crate::ProductMesh {
transmission: None,
name: "emitter".into(),
mesh: Arc::new(emitter_mesh),
color: [0; 3],
opacity: 1.0,
surface: None,
faces: Vec::new(),
},
];
let bounds = meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
let mut request = request();
request.width = 1;
request.height = 1;
request.camera.distance = 50.0;
request.camera.fov = 0.0;
request.camera.set_view(crate::StandardView::Top);
let options = RaytraceOptions {
lights: Some(Vec::new()),
shadows: false,
emissions: Some(vec![job::SurfaceEmission {
body_index: 1,
body: "emitter".into(),
color: [0.25, 0.5, 1.0],
strength: 2.0,
sides: job::EmissionSides::Front,
}]),
reflections: Some(job::ReflectionOptions {
bodies: vec![job::ReflectionBody { body: "mirror".into(), mode: job::ReflectionMode::Mirror }],
max_bounces: 1,
samples: 1,
}),
..Default::default()
};
let image = ::image::load_from_memory(&emission_png(ProductScene { meshes, bounds }, request, options)).unwrap().to_rgba8();
let schlick = (1.0 - 0.5_f64.sqrt()).powi(5);
let expected = [(0.2, 0.5), (0.5, 1.0), (0.75, 2.0)].map(|(f0, emitted)| {
let radiance = (f0 + (1.0 - f0) * schlick) * emitted;
encode8(radiance / (1.0 + radiance))
});
assert_eq!(image.get_pixel(0, 0).0, [expected[0], expected[1], expected[2], 255]);
}
#[test]
fn procedural_effects_change_completed_pngs_independently_and_zero_is_byte_identical() {
use crate::{ProductMesh, surface_patterns::SurfaceEffect};
use solidcraft_geom::Mesh;
use std::sync::Arc;
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()
});
let original = mesh.positions.clone();
let scene = ProductScene {
bounds: mesh.bounds(),
meshes: vec![ProductMesh {
transmission: None,
name: "Coupon".into(),
mesh: mesh.clone(),
color: [180; 3],
opacity: 1.0,
surface: Some(OpaqueSurface::new(Vec3::new(0.7, 0.5, 0.3), 1.0, 0.4, 1.5).unwrap()),
faces: Vec::new(),
}],
};
let effect = SurfaceEffect {
body: "Coupon".into(),
frame: Default::default(),
repeat_mm: [12.0, 17.0, 20.0],
roughness_amplitude: 0.0,
bump_amplitude_mm: 0.0,
};
let render = |effect: Option<SurfaceEffect>| {
let mut request = request();
request.width = 32;
request.height = 32;
request.camera.distance = 40.0;
request.camera.set_view(crate::StandardView::Top);
let options = RaytraceOptions { surface_effects: effect.map(|e| vec![e]), shadows: false, ..Default::default() };
request.raytrace = Some(options.clone());
let mut task = ImageTask::new(scene.clone(), request, CancelToken::default(), options).unwrap();
for _ in 0..100_000 {
if let TaskPoll::Complete(png) = task.step(16384).unwrap() {
return png;
}
}
panic!("small surface fixture did not complete");
};
let baseline = render(None);
assert_eq!(baseline, render(Some(effect.clone())));
let rough = render(Some(SurfaceEffect { roughness_amplitude: 0.3, ..effect.clone() }));
let bump = render(Some(SurfaceEffect { bump_amplitude_mm: 0.3, ..effect }));
let base = ::image::load_from_memory(&baseline).unwrap().to_rgba8();
for changed in [&rough, &bump] {
let decoded = ::image::load_from_memory(changed).unwrap().to_rgba8();
assert_eq!(decoded.dimensions(), base.dimensions());
assert_ne!(decoded, base);
for (a, b) in decoded.pixels().zip(base.pixels()) {
assert_eq!(a[3], b[3]);
}
}
assert_ne!(rough, bump);
assert_eq!(mesh.positions, original);
}
#[test]
fn surface_target_refusals_are_atomic_before_pixels_or_bvh_allocation() {
use crate::surface_patterns::SurfaceEffect;
let effect =
SurfaceEffect { body: "missing".into(), frame: Default::default(), repeat_mm: [20.0; 3], roughness_amplitude: 0.2, bump_amplitude_mm: 0.0 };
let scene = ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY };
for effects in [vec![effect.clone()], vec![effect.clone(), effect]] {
let options = RaytraceOptions { surface_effects: Some(effects), ..Default::default() };
let mut request = request();
request.raytrace = Some(options.clone());
assert_eq!(admit(&scene, &request, &options).unwrap_err().code, ErrorCode::InvalidRequest);
}
}
fn surface_consumer_fixture() -> (ProductScene, ImageRequest, RaytraceOptions) {
use crate::{ProductMesh, surface_patterns::SurfaceEffect};
use solidcraft_geom::Mesh;
use std::sync::Arc;
let mesh = Arc::new(Mesh {
positions: vec![Vec3::new(-20.0, -20.0, 0.0), Vec3::new(20.0, -20.0, 0.0), Vec3::new(20.0, 20.0, 0.0), Vec3::new(-20.0, 20.0, 0.0)],
normals: vec![Vec3::Z; 4],
triangles: vec![[0, 1, 2], [0, 2, 3]],
tri_face: vec![0, 0],
..Default::default()
});
let scene = ProductScene {
bounds: mesh.bounds(),
meshes: vec![ProductMesh {
transmission: None,
name: "Coupon".into(),
mesh,
color: [180; 3],
opacity: 1.0,
surface: Some(OpaqueSurface::new(Vec3::new(0.7, 0.5, 0.3), 1.0, 0.4, 1.5).unwrap()),
faces: Vec::new(),
}],
};
let options = RaytraceOptions {
surface_effects: Some(vec![SurfaceEffect {
body: "Coupon".into(),
frame: Default::default(),
repeat_mm: [12.0, 17.0, 20.0],
roughness_amplitude: 0.2,
bump_amplitude_mm: 0.3,
}]),
lights: Some(Vec::new()),
shadows: false,
..Default::default()
};
let mut request = request();
request.width = 1;
request.height = 1;
request.camera.distance = 40.0;
request.camera.set_view(crate::StandardView::Top);
request.raytrace = Some(options.clone());
(scene, request, options)
}
fn surface_consumer_png(mut task: ImageTask, quantum: usize) -> Vec<u8> {
for _ in 0..200_000 {
let used = task.work.used();
let poll = task.step(quantum).unwrap();
assert!(task.work.used() - used <= 4, "surface consumer exceeded public work quantum");
if let TaskPoll::Complete(png) = poll {
return png;
}
}
panic!("bounded surface consumer did not complete");
}
fn surface_constant_environment() -> crate::lighting::environment_input::EnvironmentInput {
use crate::lighting::{HdrSource, environment_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, 4).unwrap()
}
#[test]
fn surface_effect_shared_hit_reaches_directional_point_area_and_hdr_consumers() {
use crate::job::{DirectionalLightOptions, PunctualLightOptions, RectangleLightOptions};
use std::sync::Arc;
for mask in 1..16 {
for shadows in [false, true] {
let (scene, mut request, mut options) = surface_consumer_fixture();
options.shadows = shadows;
if mask & 1 != 0 {
options.lights = Some(vec![DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 2.0 }]);
}
if mask & 2 != 0 {
options.punctual_lights = Some(vec![PunctualLightOptions {
position_mm: [0.0, 0.0, 10.0],
color: [1.0; 3],
intensity: 3.0,
reference_distance_mm: 10.0,
minimum_distance_mm: 0.001,
cone: None,
}]);
}
if mask & 4 != 0 {
options.area_lights = Some(vec![RectangleLightOptions {
center_mm: [0.0, 0.0, 10.0],
edge_u_mm: [2.0, 0.0, 0.0],
edge_v_mm: [0.0, -2.0, 0.0],
color: [1.0; 3],
intensity: 5.0,
}]);
options.area_samples = Some(1);
}
let effect = options.surface_effects.as_ref().unwrap()[0].prepare().unwrap();
let changed = effect.apply(scene.meshes[0].surface.unwrap(), Vec3::Z, Vec3::Z, Vec3::ZERO).unwrap();
let mut reference_scene = scene.clone();
reference_scene.meshes[0].surface = Some(changed.surface);
Arc::make_mut(&mut reference_scene.meshes[0].mesh).normals.fill(changed.shading_normal);
let mut reference_options = options.clone();
reference_options.surface_effects = None;
let reference_request = ImageRequest { raytrace: Some(reference_options.clone()), ..request.clone() };
request.raytrace = Some(options.clone());
let environment = || {
if mask & 8 != 0 { Some(surface_constant_environment()) } else { None }
};
let expected = surface_consumer_png(
ImageTask::new_with_environment(reference_scene, reference_request, CancelToken::default(), reference_options, environment())
.unwrap(),
1,
);
for quantum in [1, 4, 16384] {
let actual = surface_consumer_png(
ImageTask::new_with_environment(scene.clone(), request.clone(), CancelToken::default(), options.clone(), environment()).unwrap(),
quantum,
);
assert_eq!(actual, expected, "mask={mask}, shadows={shadows}, quantum={quantum}");
}
}
}
}
fn surface_at_thirty_two_binding_scan() -> ImageTask {
use crate::{ProductMesh, surface_patterns::SurfaceEffect};
use solidcraft_geom::Mesh;
use std::sync::Arc;
let (mut scene, mut request, mut options) = surface_consumer_fixture();
let visible = scene.meshes.pop().unwrap();
let mut effects = Vec::with_capacity(32);
for index in 0..31 {
let name = format!("unused-{index}");
scene.meshes.push(ProductMesh {
transmission: None,
name: name.clone(),
mesh: Arc::new(Mesh::default()),
color: [255; 3],
opacity: 1.0,
surface: None,
faces: Vec::new(),
});
effects.push(SurfaceEffect { body: name, frame: Default::default(), repeat_mm: [20.0; 3], roughness_amplitude: 0.1, bump_amplitude_mm: 0.0 });
}
scene.meshes.push(visible);
effects.push(options.surface_effects.take().unwrap().remove(0));
options.surface_effects = Some(effects);
request.raytrace = Some(options.clone());
let mut task = ImageTask::new(scene, request, CancelToken::default(), options).unwrap();
for _ in 0..20_000 {
if task.pending.as_ref().is_some_and(|p| p.hit.is_some() && !p.surface_ready && p.surface_cursor == 0) {
return task;
}
task.step(1).unwrap();
}
panic!("did not reach actual unresolved surface scan");
}
#[test]
fn thirty_two_surface_bindings_resume_and_refuse_cancel_or_work_exhaustion_without_png() {
let mut task = surface_at_thirty_two_binding_scan();
for expected_cursor in [4, 8, 12, 16, 20, 24, 28, 32] {
let before = task.work.used();
assert!(matches!(task.step(16384).unwrap(), TaskPoll::Pending(_)));
assert_eq!(task.work.used() - before, 4);
let pending = task.pending.as_ref().unwrap();
assert_eq!(pending.surface_cursor, expected_cursor);
assert!(!pending.surface_ready);
assert_eq!(pending.surface_index, if expected_cursor == 32 { Some(31) } else { None });
assert!(task.pixels.is_empty() && !task.done);
}
let png = surface_consumer_png(task, 4);
assert_eq!(::image::load_from_memory(&png).unwrap().width(), 1);
for cancel in [false, true] {
let mut task = surface_at_thirty_two_binding_scan();
let before = task.work.used();
if cancel {
task.cancel.cancel();
} else {
task.work.limit = before;
}
assert_eq!(task.step(16384).err().unwrap().code, if cancel { ErrorCode::Cancelled } else { ErrorCode::LimitExceeded });
assert_eq!(task.work.used(), before);
assert_eq!(task.pending.as_ref().unwrap().surface_cursor, 0);
assert!(task.pixels.is_empty() && !task.done);
}
}
#[test]
fn surface_effects_reject_ambiguous_targets_and_active_anisotropic_overlap() {
use crate::job::{AnisotropicFaceOptions, AnisotropicOrientation};
let (scene, mut request, mut options) = surface_consumer_fixture();
let mut ambiguous = scene.clone();
ambiguous.meshes.push(scene.meshes[0].clone());
assert_eq!(admit(&ambiguous, &request, &options).unwrap_err().code, ErrorCode::InvalidRequest);
options.anisotropic_faces[0] = Some(AnisotropicFaceOptions {
body_index: 0,
body_name: "Coupon".into(),
face: 0,
tangent: [1.0, 0.0, 0.0],
orientation: AnisotropicOrientation::Zero,
roughness_x: 0.2,
roughness_y: 0.7,
});
request.raytrace = Some(options.clone());
assert_eq!(admit(&scene, &request, &options).unwrap_err().code, ErrorCode::InvalidRequest);
let identity = options.surface_effects.as_mut().unwrap().first_mut().unwrap();
identity.roughness_amplitude = 0.0;
identity.bump_amplitude_mm = 0.0;
request.raytrace = Some(options.clone());
assert!(admit(&scene, &request, &options).is_ok());
}
#[test]
fn reflected_surface_effect_uses_changed_shading_and_resets_before_emitting_secondary_hit() {
use crate::surface_patterns::SurfaceEffect;
use std::sync::Arc;
let normal = Vec3::new(1.0, 0.0, 1.0) / 2.0_f64.sqrt();
let mirror_mesh = solidcraft_geom::Mesh {
positions: 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)],
normals: vec![normal; 4],
triangles: vec![[0, 1, 2], [0, 2, 3]],
tri_face: vec![0; 2],
..Default::default()
};
let emitter_mesh = solidcraft_geom::Mesh {
positions: vec![Vec3::new(10.0, -20.0, -20.0), Vec3::new(10.0, -20.0, 20.0), Vec3::new(10.0, 20.0, 20.0), Vec3::new(10.0, 20.0, -20.0)],
normals: vec![-Vec3::X; 4],
triangles: vec![[0, 1, 2], [0, 2, 3]],
tri_face: vec![0; 2],
..Default::default()
};
let meshes = vec![
crate::ProductMesh {
transmission: None,
name: "mirror".into(),
mesh: Arc::new(mirror_mesh),
color: [255; 3],
opacity: 1.0,
surface: Some(OpaqueSurface::new(Vec3::new(0.2, 0.5, 0.75), 1.0, 0.1, 1.5).unwrap()),
faces: Vec::new(),
},
crate::ProductMesh {
transmission: None,
name: "emitter".into(),
mesh: Arc::new(emitter_mesh),
color: [0; 3],
opacity: 1.0,
surface: None,
faces: Vec::new(),
},
];
let bounds = meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
let scene = ProductScene { meshes, bounds };
let effect = SurfaceEffect {
body: "mirror".into(),
frame: Default::default(),
repeat_mm: [12.0, 17.0, 20.0],
roughness_amplitude: 0.2,
bump_amplitude_mm: 0.3,
};
let changed = effect.prepare().unwrap().apply(scene.meshes[0].surface.unwrap(), normal, normal, Vec3::ZERO).unwrap();
let mut reference_scene = scene.clone();
reference_scene.meshes[0].surface = Some(changed.surface);
Arc::make_mut(&mut reference_scene.meshes[0].mesh).normals.fill(changed.shading_normal);
let mut request = request();
request.width = 1;
request.height = 1;
request.camera.distance = 50.0;
request.camera.fov = 0.0;
request.camera.set_view(crate::StandardView::Top);
for mode in [job::ReflectionMode::Mirror, job::ReflectionMode::RoughSpecular] {
let options = RaytraceOptions {
surface_effects: Some(vec![effect.clone()]),
lights: Some(Vec::new()),
shadows: false,
emissions: Some(vec![job::SurfaceEmission {
body_index: 1,
body: "emitter".into(),
color: [0.25, 0.5, 1.0],
strength: 2.0,
sides: job::EmissionSides::Front,
}]),
reflections: Some(job::ReflectionOptions {
bodies: vec![job::ReflectionBody { body: "mirror".into(), mode }],
max_bounces: 2,
samples: 16,
}),
..Default::default()
};
let mut reference_options = options.clone();
reference_options.surface_effects = None;
let expected = emission_png(reference_scene.clone(), request.clone(), reference_options);
assert_eq!(emission_png(scene.clone(), request.clone(), options), expected, "mode={mode:?}");
let decoded = ::image::load_from_memory(&expected).unwrap().to_rgba8();
assert!(decoded.get_pixel(0, 0).0[..3].iter().any(|value| *value > 0));
}
}
fn dielectric_triangle_task(cancel: CancelToken) -> ImageTask {
let task = triangle_task(cancel.clone());
let mut request = task.request;
let options = RaytraceOptions {
dielectrics: vec![job::DielectricOptions {
model: None,
shadow_transmission: false,
subsurface: None,
body_index: 0,
body_name: "work fixture".into(),
boundary: job::DielectricBoundary::ThinSheet,
ior: 1.5,
absorption_per_mm: [0.0; 3],
thickness_mm: 0.0,
}],
shadows: false,
..Default::default()
};
request.raytrace = Some(options.clone());
ImageTask::new(task.scene, request, cancel, options).unwrap()
}
#[test]
fn dielectric_branch_traversal_exhausts_the_same_job_work_budget() {
let mut task = dielectric_triangle_task(CancelToken::default());
for _ in 0..100_000 {
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
if task.optical.first().and_then(|optical| optical.pending.as_ref()).is_some_and(|state| state.paths > 1) {
assert!(task.work.used() > task.build_used);
task.work.limit = task.work.used();
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::LimitExceeded);
assert!(!task.done);
return;
}
}
panic!("dielectric branch not reached");
}
#[test]
fn completed_dielectric_png_releases_capture_and_path_state() {
let mut task = dielectric_triangle_task(CancelToken::default());
let weak = std::sync::Arc::downgrade(&task.scene.meshes[0].mesh);
for _ in 0..100_000 {
if let TaskPoll::Complete(png) = task.step(16384).unwrap() {
assert!(::image::load_from_memory(&png).is_ok());
assert!(weak.upgrade().is_none());
assert!(task.optical.is_empty());
assert!(task.options.dielectrics.is_empty());
assert!(task.request.raytrace.is_none());
assert!(task.bvh.is_none());
return;
}
}
panic!("dielectric fixture did not complete");
}
#[test]
fn dielectric_fixed_stack_and_path_caps_return_typed_failures() {
let ray = Ray::new(Vec3::Z, -Vec3::Z, 0.0, 2.0).unwrap();
let mut state = DielectricPixel::new(ray);
state.paths = MAX_PATHS;
assert_eq!(state.push(state.path).err().unwrap().code, ErrorCode::LimitExceeded);
state.paths = 1;
state.stack_len = state.stack.len();
assert_eq!(state.push(state.path).err().unwrap().code, ErrorCode::LimitExceeded);
}
#[test]
fn dielectric_image_path_applies_radiance_eta_squared_at_each_interface() {
let options = RaytraceOptions {
dielectrics: vec![dielectric::tests::input(job::DielectricBoundary::ClosedBox)],
lights: Some(Vec::new()),
shadows: false,
..Default::default()
};
let mut request = dielectric::tests::request(options.clone());
request.camera.pitch = std::f64::consts::FRAC_PI_2;
let mut task = ImageTask::new(dielectric::tests::scene(dielectric::tests::box_body(2.0)), request, CancelToken::default(), options).unwrap();
let mut entry = None;
for _ in 0..100_000 {
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
if let Some(state) = task.optical.first().and_then(|optical| optical.pending.as_ref()) {
let path = state.path;
if path.boundaries == 1 && path.medium == Some(0) {
// Air -> glass at normal incidence: (1-F0)/n^2 = .96/2.25.
let expected = 0.96 / 2.25;
assert!((path.throughput.x - expected).abs() < 1e-13);
assert!((path.throughput.y - expected).abs() < 1e-13);
assert!((path.throughput.z - expected).abs() < 1e-13);
entry = Some(path.throughput.x);
}
if path.boundaries == 2 && path.medium.is_none() {
// Glass -> air independently multiplies by .96*n^2 = 2.16.
let ratio = path.throughput.x / entry.expect("entry checked before exit");
assert!((ratio - 2.16).abs() < 1e-13);
return;
}
}
}
panic!("slab's first entry and exit were not observed");
}
fn optical_sheet(name: &str, x: f64, z: f64) -> crate::ProductMesh {
use std::sync::Arc;
crate::ProductMesh {
transmission: None,
name: name.into(),
mesh: Arc::new(solidcraft_geom::Mesh {
positions: vec![Vec3::new(x - 20.0, -20.0, z), Vec3::new(x + 20.0, -20.0, z), Vec3::new(x + 20.0, 20.0, z), Vec3::new(x - 20.0, 20.0, z)],
normals: vec![Vec3::Z; 4],
triangles: vec![[0, 1, 2], [0, 2, 3]],
..Default::default()
}),
color: [255; 3],
opacity: 1.0,
surface: None,
faces: Vec::new(),
}
}
fn optical_input(body_index: usize, body_name: &str, ior: f64) -> job::DielectricOptions {
job::DielectricOptions {
model: None,
shadow_transmission: false,
subsurface: None,
body_index,
body_name: body_name.into(),
boundary: job::DielectricBoundary::ThinSheet,
ior,
absorption_per_mm: [0.0; 3],
thickness_mm: 0.0,
}
}
fn optical_png(mut task: ImageTask, quantum: usize) -> Vec<u8> {
for _ in 0..2_000_000 {
let before = task.work.used();
let poll = task.step(quantum).unwrap();
assert!(task.work.used() - before <= 4, "an optical continuation exceeded the shared work quantum");
if let TaskPoll::Complete(png) = poll {
return png;
}
}
panic!("bounded optical fixture did not finish");
}
#[test]
fn dielectric_branches_sum_inside_each_spatial_and_reflection_attempt() {
let mut scene = dielectric::tests::scene(dielectric::tests::box_body(2.0));
scene.meshes.push(optical_sheet("unused reflector", 100.0, 0.0));
scene.bounds = scene.meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
let mut baseline = None;
for spatial in [1, 4, 16] {
for attempts in [1, 4, 16] {
let options = RaytraceOptions {
primary_samples: spatial,
dielectrics: vec![dielectric::tests::input(job::DielectricBoundary::ClosedBox)],
environment: Some(job::RaytraceEnvironmentOptions { color: [1.0; 3], intensity: 1.0 }),
reflections: Some(job::ReflectionOptions {
bodies: vec![job::ReflectionBody { body: "unused reflector".into(), mode: job::ReflectionMode::Mirror }],
samples: attempts,
max_bounces: 1,
}),
lights: Some(Vec::new()),
shadows: false,
..Default::default()
};
let mut request = dielectric::tests::request(options.clone());
request.camera.distance = 10.0;
request.camera.fov = 0.0;
for quantum in [1, 4, 16384] {
let mut task = ImageTask::new(scene.clone(), request.clone(), CancelToken::default(), options.clone()).unwrap();
let mut saw_complete_coverage = false;
let mut done = None;
for _ in 0..2_000_000 {
let before = task.work.used();
let poll = task.step(quantum).unwrap();
assert!(task.work.used() - before <= 4);
assert!(task.primary_coverage <= u16::from(spatial) * u16::from(attempts));
if task.emit_spatial_pixel {
assert_eq!(task.primary_coverage, u16::from(spatial) * u16::from(attempts), "branches are not coverage samples");
saw_complete_coverage = true;
}
if let Some(state) = task.optical.first().and_then(|o| o.pending.as_ref())
&& state.path.boundaries > 0
{
assert!(!task.pending.as_ref().unwrap().repeatable_primary, "selected optical paths have no opaque reuse proof");
}
if let TaskPoll::Complete(png) = poll {
done = Some(png);
break;
}
}
let png = done.expect("bounded optical AA fixture completes");
// A four-unit call may commit/reset coverage before yielding. The
// one-unit run observes that state; every quantum checks final bytes.
if spatial != 1 && quantum == 1 {
assert!(saw_complete_coverage);
}
let rgba = ::image::load_from_memory(&png).unwrap().to_rgba8();
let pixel = rgba.get_pixel(0, 0).0;
assert!(pixel[0] > 150 && pixel[0] == pixel[1] && pixel[1] == pixel[2]);
if let Some(expected) = &baseline {
assert_eq!(&png, expected, "S={spatial}, R={attempts}, quantum={quantum}; branches sum, S/R average");
} else {
baseline = Some(png);
}
}
}
}
}
#[test]
fn unit_ior_sheet_rejoins_surface_emission_and_every_existing_light_consumer() {
use job::{DirectionalLightOptions, PunctualLightOptions, RectangleLightOptions};
for mask in 1..16 {
let (scene, mut request, mut options) = surface_consumer_fixture();
request.camera.fov = 0.0;
request.camera.distance = 10.0;
// Shadows are deliberately off: this preview's shadow rays conservatively
// treat every dielectric boundary as an opaque blocker.
options.shadows = false;
if mask & 1 != 0 {
options.lights = Some(vec![DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 2.0 }]);
}
if mask & 2 != 0 {
options.punctual_lights = Some(vec![PunctualLightOptions {
position_mm: [0.0, 0.0, 10.0],
color: [1.0; 3],
intensity: 3.0,
reference_distance_mm: 10.0,
minimum_distance_mm: 0.001,
cone: None,
}]);
}
if mask & 4 != 0 {
options.area_lights = Some(vec![RectangleLightOptions {
center_mm: [0.0, 0.0, 10.0],
edge_u_mm: [2.0, 0.0, 0.0],
edge_v_mm: [0.0, -2.0, 0.0],
color: [1.0; 3],
intensity: 5.0,
}]);
options.area_samples = Some(4);
}
options.emissions = Some(vec![job::SurfaceEmission {
body_index: 0,
body: "Coupon".into(),
color: [0.1, 0.2, 0.3],
strength: 0.5,
sides: job::EmissionSides::Front,
}]);
request.raytrace = Some(options.clone());
let environment = || {
if mask & 8 != 0 { Some(surface_constant_environment()) } else { None }
};
let expected = optical_png(
ImageTask::new_with_environment(scene.clone(), request.clone(), CancelToken::default(), options.clone(), environment()).unwrap(),
1,
);
let mut transmitted_scene = scene;
transmitted_scene.meshes.push(optical_sheet("sheet", 0.0, 5.0));
transmitted_scene.bounds = transmitted_scene.meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
options.dielectrics = vec![optical_input(1, "sheet", 1.0)];
request.raytrace = Some(options.clone());
for quantum in [1, 4, 16384] {
let actual = optical_png(
ImageTask::new_with_environment(transmitted_scene.clone(), request.clone(), CancelToken::default(), options.clone(), environment())
.unwrap(),
quantum,
);
assert_eq!(actual, expected, "the same opaque light/surface/emission consumer after transmission; mask={mask}");
}
}
}
fn optical_at_eight_selector_scan() -> ImageTask {
let (mut scene, mut request, mut options) = surface_consumer_fixture();
for i in 0..8 {
let name = format!("unused sheet {i}");
let index = scene.meshes.len();
scene.meshes.push(optical_sheet(&name, 100.0 + 50.0 * f64::from(i), 5.0));
options.dielectrics.push(optical_input(index, &name, 1.5));
}
scene.bounds = scene.meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
request.raytrace = Some(options.clone());
let mut task = ImageTask::new(scene, request, CancelToken::default(), options).unwrap();
for _ in 0..200_000 {
if task.pending.as_ref().is_some_and(|p| p.hit.is_some())
&& task.optical.first().and_then(|o| o.pending.as_ref()).is_some_and(|p| !p.ready && p.selector == 0)
{
return task;
}
task.step(1).unwrap();
}
panic!("actual optical selector scan not reached");
}
#[test]
fn eight_optical_selectors_resume_with_cancel_and_work_checks_before_mutation() {
let mut task = optical_at_eight_selector_scan();
for expected in [4, 8] {
let before = task.work.used();
assert!(matches!(task.step(16384).unwrap(), TaskPoll::Pending(_)));
assert_eq!(task.work.used() - before, 4);
let state = task.optical[0].pending.as_ref().unwrap();
assert_eq!(state.selector, expected);
assert!(!state.ready);
assert!(task.pixels.is_empty());
}
assert!(!optical_png(task, 4).is_empty());
for cancelled in [false, true] {
let mut task = optical_at_eight_selector_scan();
let before = task.work.used();
if cancelled {
task.cancel.cancel();
} else {
task.work.limit = before;
}
assert_eq!(task.step(4).err().unwrap().code, if cancelled { ErrorCode::Cancelled } else { ErrorCode::LimitExceeded });
assert_eq!(task.work.used(), before);
assert_eq!(task.optical[0].pending.as_ref().unwrap().selector, 0);
assert!(task.pixels.is_empty() && task.encoder.is_none() && !task.done);
}
}
#[test]
fn optical_reuse_rejects_an_undrained_branch_and_a_selected_primary() {
fn reusable() -> ImageTask {
let mut task = optical_at_eight_selector_scan();
// Start a fresh coherent request with an unreachable ordinary reflector to
// request R=4, and a spatial grid whose visible receiver remains opaque.
let mut scene = task.scene.clone();
let mut request = task.request.clone();
let mut options = task.options.clone();
scene.meshes.push(optical_sheet("unused reflector", 1000.0, 0.0));
scene.bounds = scene.meshes.iter().fold(Aabb3::EMPTY, |b, m| b.union(&m.mesh.bounds()));
options.primary_samples = 4;
options.reflections = Some(job::ReflectionOptions {
bodies: vec![job::ReflectionBody { body: "unused reflector".into(), mode: job::ReflectionMode::Mirror }],
max_bounces: 1,
samples: 4,
});
request.camera.distance = 10.0;
request.camera.fov = 0.0;
request.raytrace = Some(options.clone());
task = ImageTask::new(scene, request, CancelToken::default(), options).unwrap();
for _ in 0..200_000 {
if task.pending.as_ref().is_some_and(|p| p.light == task.lights.lights().len() + 1) {
assert!(task.optical[0].pending.is_none(), "only drained optics reach the completed opaque marker");
return task;
}
task.step(1).unwrap();
}
panic!("completed nonselected primary marker not reached");
}
for pending_branch in [false, true] {
let mut task = reusable();
if pending_branch {
task.optical[0].pending = Some(DielectricPixel::new(task.pending.as_ref().unwrap().ray));
} else {
task.options.dielectrics[0].body_index = 0;
task.options.dielectrics[0].body_name = "Coupon".into();
}
let before = task.primary_coverage;
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::InvalidScene);
assert_eq!(task.primary_coverage, before);
assert!(task.pixels.is_empty());
}
}
#[test]
fn optical_admission_bills_capacity_and_refuses_ambiguous_effect_and_environment_contracts() {
let scene = dielectric::tests::scene(dielectric::tests::box_body(2.0));
let mut options = RaytraceOptions { dielectrics: vec![dielectric::tests::input(job::DielectricBoundary::ClosedBox)], ..Default::default() };
let name = scene.meshes[0].name.clone();
let bytes = options.retained_bytes().unwrap();
assert_eq!(
bytes,
options.dielectrics.capacity() as u64 * std::mem::size_of::<job::DielectricOptions>() as u64
+ options.dielectrics[0].body_name.capacity() as u64
);
let mut request = dielectric::tests::request(options.clone());
let with_optics = admit(&scene, &request, &options).unwrap();
let plain = RaytraceOptions::default();
let plain_request = ImageRequest { raytrace: Some(plain.clone()), ..request.clone() };
let without_optics = admit(&scene, &plain_request, &plain).unwrap();
assert_eq!(
with_optics.estimated_total_bytes - without_optics.estimated_total_bytes,
bytes
+ request.raytrace.as_ref().unwrap().retained_dielectric_bytes().unwrap()
+ std::mem::size_of::<OpticalTask>() as u64
+ super::super::legacy_certificates::Task::required_bytes(&scene, &options).unwrap()
+ std::mem::size_of::<super::CertifiedOptics>() as u64
);
options.surface_effects = Some(vec![crate::surface_patterns::SurfaceEffect {
body: name,
frame: Default::default(),
repeat_mm: [10.0; 3],
roughness_amplitude: 0.1,
bump_amplitude_mm: 0.0,
}]);
request.raytrace = Some(options.clone());
assert_eq!(admit(&scene, &request, &options).unwrap_err().code, ErrorCode::InvalidScene);
options.surface_effects.as_mut().unwrap()[0].roughness_amplitude = 0.0;
request.raytrace = Some(options.clone());
assert!(admit(&scene, &request, &options).is_ok(), "an identity opaque effect does not change the geometric boundary");
options.environment = Some(job::RaytraceEnvironmentOptions { color: [1.0; 3], intensity: 1.0 });
request.raytrace = Some(options.clone());
assert_eq!(
options.validate_environment_reflections(&scene).unwrap_err().code,
ErrorCode::InvalidRequest,
"the same guard is called by engine preflight and host admission"
);
assert_eq!(
ImageTask::new_with_environment(
scene.clone(),
request.clone(),
CancelToken::default(),
options.clone(),
Some(surface_constant_environment())
)
.err()
.unwrap()
.code,
ErrorCode::InvalidRequest
);
options.dielectrics = Vec::with_capacity(9);
assert_eq!(options.validate().unwrap_err().code, ErrorCode::InvalidRequest);
}
#[test]
fn captured_clear_coat_keeps_direct_shading_but_refuses_unmatched_cpu_transport() {
let (mut scene, mut request, mut options) = emission_fixture(false);
let coat = crate::clear_coat::ClearCoat::new(0.8, 0.2, 1.5).unwrap();
let surface = OpaqueSurface::new(Vec3::new(0.4, 0.3, 0.2), 0.0, 0.4, 1.5).unwrap().with_clear_coat(coat);
scene.meshes[0].surface = Some(surface);
request.raytrace = Some(options.clone());
admit(&scene, &request, &options).unwrap();
options.reflections = Some(job::ReflectionOptions {
bodies: vec![job::ReflectionBody { body: "emitter".into(), mode: job::ReflectionMode::RoughSpecular }],
max_bounces: 1,
samples: 1,
});
request.raytrace = Some(options.clone());
assert!(admit(&scene, &request, &options).unwrap_err().message.contains("clear-coat transport"));
scene.meshes[0].surface = None;
scene.meshes[0].faces.push(crate::FaceAppearance { face: 0, color: [255; 3], opacity: 1.0, surface: Some(surface), transmission: None });
assert!(admit(&scene, &request, &options).unwrap_err().message.contains("clear-coat transport"));
}
#[test]
fn pending_pixel_heap_slot_stays_single_and_reuses_storage_until_completion() {
let mut task = triangle_task(CancelToken::default());
let initial = task.pending.0.as_ptr();
assert_eq!(task.pending.0.capacity(), 1);
assert!(task.pending.is_none());
assert!(std::mem::size_of::<ImageTask>() <= 4096);
let expected = admit(&task.scene, &task.request, &task.options).unwrap();
assert_eq!(task.admission.estimated_total_bytes, expected.estimated_total_bytes);
assert!(expected.preparation_bytes >= PendingPixelSlot::required_bytes());
let mut seen = false;
let mut completed = false;
for _ in 0..100_000 {
match task.step(1).unwrap() {
TaskPoll::Pending(_) => {
assert_eq!(task.pending.0.capacity(), 1);
assert_eq!(task.pending.0.as_ptr(), initial, "samples must reuse the one admitted continuation slot");
assert!(task.pending.0.len() <= 1);
seen |= task.pending.is_some();
}
TaskPoll::Complete(png) => {
assert!(png.starts_with(b"\x89PNG\r\n\x1a\n"));
assert_eq!(task.pending.0.capacity(), 0, "completed task releases continuation storage before its lease is shrunk");
assert!(task.pending.is_none());
completed = true;
break;
}
}
}
assert!(completed, "fixture must complete within its bounded test work");
assert!(seen, "fixture must exercise a live resumable pixel");
}
#[test]
fn cancelled_pending_pixel_allocation_is_refused_before_any_continuation() {
let cancel = CancelToken::default();
cancel.cancel();
assert_eq!(PendingPixelSlot::new(&cancel).err().unwrap().code, ErrorCode::Cancelled);
}
fn progressive_optics_fixture(samples: u32, thin: bool, ior: f64, cancel: CancelToken) -> ImageTask {
let mut body = dielectric::tests::box_body(8.0);
let boundary = if thin {
std::sync::Arc::make_mut(&mut body.mesh).triangles = vec![[4, 5, 7], [4, 7, 6]];
job::DielectricBoundary::ThinSheet
} else {
job::DielectricBoundary::ClosedBox
};
let mut material = dielectric::tests::input(boundary);
material.ior = ior;
material.absorption_per_mm = [0.1, 0.2, 0.0];
material.thickness_mm = if thin { 8.0 } else { 0.0 };
let options = RaytraceOptions {
progressive: Some(job::CpuProgressiveOptions { samples_per_pixel: samples, seed: 83 }),
dielectrics: vec![material],
environment: Some(job::RaytraceEnvironmentOptions { color: [1.0; 3], intensity: 1.0 }),
lights: Some(Vec::new()),
shadows: false,
..Default::default()
};
let mut request = dielectric::tests::request(options.clone());
// A small parallel camera keeps every independently jittered sample well inside
// the certified slab; this analytic fixture does not sample a boundary edge.
request.camera.distance = 10.0;
request.camera.fov = 0.0;
ImageTask::new(dielectric::tests::scene(body), request, cancel, options).unwrap()
}
fn progressive_optics_complete(mut task: ImageTask, quantum: usize) -> (Vec<(u32, Vec<u8>)>, Vec<u8>, u64) {
let mut previews = Vec::new();
let mut branches = 0;
for _ in 0..2_000_000 {
let used = task.work.used();
let transport = task.progress().phase == Phase::Running;
let poll = task.step_with_previews(quantum).unwrap();
if quantum == 1 && transport {
assert!(task.work.used() - used <= 4, "an optical continuation exceeded the shared work quantum");
}
assert!(task.primary_coverage <= 1, "Fresnel branches cannot become additional camera coverage samples");
if let Some(state) = task.optical.first().and_then(|o| o.pending.as_ref())
&& state.path.boundaries > 0
{
branches += 1;
assert!(!task.pending.as_ref().unwrap().repeatable_primary);
}
match poll {
ImagePoll::Pending(_) => {}
ImagePoll::Preview { png, samples_per_pixel } => {
assert!(task.optical.first().is_some_and(|o| o.pending.is_none()), "a complete pass must drain every optical branch");
previews.push((samples_per_pixel, png));
}
ImagePoll::Complete(png) => {
assert!(branches > 0, "the actual image producer must consume optical interfaces");
assert!(task.optical.is_empty());
return (previews, png, task.work.used());
}
}
}
panic!("bounded progressive optical fixture did not finish");
}
#[test]
fn progressive_certified_optics_keep_beer_lambert_energy_prefixes_and_shared_work() {
for thin in [false, true] {
for ior in [1.0, 1.5] {
let actual = progressive_optics_complete(progressive_optics_fixture(5, thin, ior, CancelToken::default()), 1);
assert_eq!(actual.0.iter().map(|p| p.0).collect::<Vec<_>>(), [1, 2, 3, 4]);
assert_eq!(actual, progressive_optics_complete(progressive_optics_fixture(5, thin, ior, CancelToken::default()), 16_384));
for (samples, png) in &actual.0 {
let prefix = progressive_optics_complete(progressive_optics_fixture(*samples, thin, ior, CancelToken::default()), 3);
assert_eq!(*png, prefix.1, "target sample count must not change an optical prefix");
}
if ior == 1.0 {
// Index-matched slab/sheet: no reflection, exactly eight millimetres
// of Beer attenuation in each independent camera sample.
let linear = Vec3::new((-0.8f64).exp(), (-1.6f64).exp(), 1.0);
let mapped = map_to_display(linear, 0.0).unwrap();
let expected = [encode8(mapped.x), encode8(mapped.y), encode8(mapped.z), 255];
assert_eq!(::image::load_from_memory(&actual.1).unwrap().to_rgba8().get_pixel(0, 0).0, expected);
}
}
}
}
#[test]
fn progressive_certified_optical_branches_cancel_and_exhaust_before_any_late_pass() {
for exhausted in [false, true] {
let cancel = CancelToken::default();
let mut task = progressive_optics_fixture(5, false, 1.5, cancel.clone());
let mut stopped = false;
for _ in 0..200_000 {
assert!(matches!(task.step_with_previews(1).unwrap(), ImagePoll::Pending(_)));
if task.optical.first().and_then(|o| o.pending.as_ref()).is_some_and(|state| state.path.boundaries > 0) {
let used = task.work.used();
if exhausted {
task.work.limit = used;
} else {
cancel.cancel();
}
assert_eq!(task.step_with_previews(1).err().unwrap().code, if exhausted { ErrorCode::LimitExceeded } else { ErrorCode::Cancelled });
assert_eq!(task.work.used(), used);
assert!(!task.done);
stopped = true;
break;
}
}
assert!(stopped, "test must stop inside a real Fresnel branch");
}
}
type DenoiseOracleGuide = [[f64; 4]; 3];
fn dot(a: [f64; 3], b: [f64; 3]) -> f64 {
a.into_iter().zip(b).map(|(x, y)| x * y).sum()
}
fn diff(a: [f64; 4], b: [f64; 4]) -> [f64; 3] {
[a[0] - b[0], a[1] - b[1], a[2] - b[2]]
}
fn xyz(a: [f64; 4]) -> [f64; 3] {
[a[0], a[1], a[2]]
}
// Independent f64 gather oracle: all inputs are averaged linear values, so the
// GPU's accumulated-sample scaling is absent from this numerical implementation.
fn cpu_denoise_reference(width: usize, input: &[[f64; 4]], guides: &[DenoiseOracleGuide], step: usize) -> Vec<[f64; 4]> {
let height = input.len() / width;
let kernel = [1.0, 4.0, 6.0, 4.0, 1.0];
input
.iter()
.enumerate()
.map(|(i, ¢er)| {
let [a, n, p] = guides[i];
if a[3] == 0.0 || center[3] < 0.999 {
return center;
}
let mut result = [0.0; 4];
let mut total = 0.0;
for (ky, &wy) in kernel.iter().enumerate() {
for (kx, &wx) in kernel.iter().enumerate() {
let x = (i % width) as isize + (kx as isize - 2) * step as isize;
let y = (i / width) as isize + (ky as isize - 2) * step as isize;
if x < 0 || y < 0 || x >= width as isize || y >= height as isize {
continue;
}
let j = y as usize * width + x as usize;
let [b, m, q] = guides[j];
let value = input[j];
if a[3] != b[3] || (value[3] - center[3]).abs() > 0.01 {
continue;
}
let albedo = diff(a, b);
let position = diff(q, p);
let plane = dot(position, xyz(n)).abs() + dot(position, xyz(m)).abs();
let scale = (0.05 * p[3].max(q[3]) * step as f64).max(1e-6);
let depth = (n[3] - m[3]).abs() / (8.0 * p[3].max(q[3]) * step as f64).max(1e-6);
let color = diff(center, value);
let maximum = |v: [f64; 3]| v.into_iter().fold(0.0, f64::max);
let color_scale = 0.25 + 0.5 * maximum(xyz(center)).max(maximum(xyz(value)));
let weight = wx
* wy
* (-dot(albedo, albedo) / 0.04 - plane / scale - depth - maximum(color.map(f64::abs)) / color_scale).exp()
* dot(xyz(n), xyz(m)).max(0.0).powi(32);
for k in 0..3 {
result[k] += value[k] * weight;
}
total += weight;
}
}
for v in result.iter_mut().take(3) {
*v /= total;
}
result[3] = center[3];
result
})
.collect()
}
fn denoise_test_guide(x: usize, y: usize) -> job::denoise::Guide {
job::denoise::Guide { albedo: [0.5; 3], body: 1, normal: [0.0, 0.0, 1.0], depth: 4.0, position: [x as f32, y as f32, 0.0], footprint: 1.0 }
}
fn oracle_guides(guides: &[job::denoise::Guide]) -> Vec<DenoiseOracleGuide> {
guides
.iter()
.map(|g| {
[
[f64::from(g.albedo[0]), f64::from(g.albedo[1]), f64::from(g.albedo[2]), f64::from(g.body)],
[f64::from(g.normal[0]), f64::from(g.normal[1]), f64::from(g.normal[2]), f64::from(g.depth)],
[f64::from(g.position[0]), f64::from(g.position[1]), f64::from(g.position[2]), f64::from(g.footprint)],
]
})
.collect()
}
fn complete_denoise(width: u32, pixels: Vec<[f32; 4]>, guides: &[job::denoise::Guide]) -> (Vec<[f32; 4]>, usize) {
let mut task = job::denoise::DenoiseTask::new(width, pixels.len() as u32 / width, pixels).unwrap();
let mut visits = 0;
for _ in 0..1000 {
let count = task.next_pixels();
assert!(count <= job::denoise::MAX_STEP_PIXELS);
visits += count;
if task.step(guides, &CancelToken::default()).unwrap() {
return (task.finish().unwrap(), visits);
}
}
panic!("bounded filter did not finish")
}
#[test]
fn cpu_atrous_matches_independent_f64_gather_preserves_hdr_coverage_and_edges() {
let width = 17u32;
let count = (width * width) as usize;
let guides: Vec<_> = (0..count).map(|i| denoise_test_guide(i % 17, i / 17)).collect();
let pixels: Vec<_> = (0..count)
.map(|i| {
let hash = (i as u32).wrapping_mul(2654435761);
let value = 0.4 + 0.2 * (hash >> 8) as f32 / 16777216.0;
[value, value * 0.7, value * 1.3, 1.0]
})
.collect();
let original = pixels.clone();
let saved = guides.clone();
let (actual, visits) = complete_denoise(width, pixels, &guides);
let mut expected: Vec<_> = original.iter().map(|p| p.map(f64::from)).collect();
for step in [1, 2, 4] {
expected = cpu_denoise_reference(17, &expected, &oracle_guides(&guides), step);
}
assert_eq!(visits, 3 * count, "bounded pixel visits, not an invented scalar-FLOP budget");
for (a, b) in actual.iter().zip(expected) {
for c in 0..4 {
assert!((f64::from(a[c]) - b[c]).abs() < 2e-6)
}
}
let variance = |v: &[[f32; 4]]| {
let mean = v.iter().map(|p| f64::from(p[0])).sum::<f64>() / v.len() as f64;
v.iter().map(|p| (f64::from(p[0]) - mean).powi(2)).sum::<f64>() / v.len() as f64
};
assert!(variance(&actual) < variance(&original) / 4.0);
assert_eq!(guides.iter().map(|g| g.position).collect::<Vec<_>>(), saved.iter().map(|g| g.position).collect::<Vec<_>>());
for constant in [[0.75, 0.25, 0.5, 1.0], [1e30, 1e20, 1e10, 1.0], [0.7, 0.3, 0.1, 0.5]] {
assert_eq!(complete_denoise(width, vec![constant; count], &guides).0, vec![constant; count]);
}
for edge in 0..6 {
let mut g = guides.clone();
let mut p = vec![[0.0, 0.0, 0.0, 1.0]; count];
for (i, value) in p.iter_mut().enumerate() {
if i % 17 >= 8 {
*value = [1.0; 4];
match edge {
0 => g[i].body = 2,
1 => g[i].normal = [1.0, 0.0, 0.0],
2 => g[i].position[2] = 10.0,
3 => g[i].albedo = [1.0; 3],
4 => g[i].depth = 1004.0,
_ => g[i].body = 0,
}
} else if edge == 3 {
g[i].albedo = [0.0; 3]
}
}
let filtered = complete_denoise(width, p.clone(), &g).0;
assert!(filtered.iter().zip(p).all(|(a, b)| (a[0] - b[0]).abs() < 1e-12), "edge {edge}");
}
let bypass = vec![job::denoise::Guide::default(); count];
assert_eq!(complete_denoise(width, original.clone(), &bypass).0, original);
}
fn denoised_plane(samples: u32, denoise: bool, output: Option<job::OutputOptions>) -> ImageTask {
let (scene, mut request, _) = emission_fixture(false);
request.width = 13;
request.height = 13;
let options = RaytraceOptions {
denoise,
output: output.map(Box::new),
progressive: Some(job::CpuProgressiveOptions { samples_per_pixel: samples, seed: 7 }),
lights: Some(Vec::new()),
area_lights: Some(vec![job::RectangleLightOptions {
center_mm: [0.0, 0.0, 10.0],
edge_u_mm: [14.0, 0.0, 0.0],
edge_v_mm: [0.0, -14.0, 0.0],
color: [1.0, 0.7, 0.3],
intensity: 10.0,
}]),
area_samples: Some(1),
seed: Some(31),
..Default::default()
};
request.raytrace = Some(options.clone());
ImageTask::new(scene, request, CancelToken::default(), options).unwrap()
}
type DenoisedImageOutput = (Vec<(u32, Vec<u8>)>, Vec<u8>, Option<Vec<u8>>, u64);
fn finish_denoise_image(mut task: ImageTask, units: usize) -> DenoisedImageOutput {
let mut previews = Vec::new();
for _ in 0..300000 {
match task.step_with_previews(units).unwrap() {
ImagePoll::Pending(_) => {}
ImagePoll::Preview { png, samples_per_pixel } => {
assert!(task.take_linear_exr().is_none());
previews.push((samples_per_pixel, png));
}
ImagePoll::Complete(png) => {
assert_eq!(task.denoise.capacity(), 0, "guides are work-owned, never retained with the final master");
return (previews, png, task.take_linear_exr(), task.work.used());
}
}
}
panic!("bounded denoised image did not finish")
}
#[test]
fn cpu_denoising_filters_actual_complete_prefixes_without_changing_raw_film_or_exr() {
let output = job::OutputOptions { linear_exr: true, ..Default::default() };
let first = finish_denoise_image(denoised_plane(4, true, Some(output)), 1);
assert_eq!(first.0.iter().map(|p| p.0).collect::<Vec<_>>(), [1, 2, 3]);
assert_eq!(first, finish_denoise_image(denoised_plane(4, true, Some(output)), 16384));
for (samples, png) in &first.0 {
assert_eq!(png, &finish_denoise_image(denoised_plane(*samples, true, Some(output)), 3).1)
}
let raw = finish_denoise_image(denoised_plane(4, false, Some(output)), 1);
assert_eq!(first.2, raw.2, "EXR is encoded before filtering from identical absolute Monte Carlo samples");
assert_ne!(first.1, raw.1, "the actual CPU soft-light picture must pass through the filter");
let mut task = denoised_plane(2, true, None);
for _ in 0..300000 {
if task.linear.len() == 169 && task.output.is_empty() {
break;
}
assert!(!matches!(task.step_with_previews(1).unwrap(), ImagePoll::Complete(_)));
}
assert_eq!(task.linear.len(), 169);
let guides = task.denoise.first().unwrap().pixels().unwrap().to_vec();
assert!(guides.iter().all(|g| g.body > 0));
assert!(guides.iter().all(|g| (g.normal[2] - 1.0).abs() < 1e-6));
let film: Vec<_> = (0..169).map(|i| task.progressive.as_ref().unwrap().film.pixel(i).unwrap()).collect();
let mut expected: Vec<_> = task.linear.iter().map(|p| p.map(f64::from)).collect();
for step in [1, 2, 4] {
expected = cpu_denoise_reference(13, &expected, &oracle_guides(&guides), step)
.into_iter()
.map(|pixel| pixel.map(|value| f64::from(value as f32)))
.collect()
}
let linear: Vec<_> = expected.iter().map(|p| p.map(|v| v as f32)).collect();
let mut rgba = vec![0; 169 * 4];
job::presentation::Presentation { background: task.request.background, ..Default::default() }
.display(13, 13)
.unwrap()
.encode(&linear, &mut rgba, &CancelToken::default())
.unwrap();
let png = loop {
match task.step_with_previews(1).unwrap() {
ImagePoll::Preview { png, .. } => break png,
ImagePoll::Pending(_) => {}
ImagePoll::Complete(_) => panic!("first prefix was lost"),
}
};
assert_eq!(::image::load_from_memory(&png).unwrap().to_rgba8().as_raw(), &rgba);
assert_eq!((0..169).map(|i| task.progressive.as_ref().unwrap().film.pixel(i).unwrap()).collect::<Vec<_>>(), film);
}
#[test]
fn cpu_denoising_admits_actual_guides_and_colour_scratch_only_when_enabled() {
let plain = denoised_plane(4, false, None);
let filtered = denoised_plane(4, true, None);
assert_eq!(plain.denoise.capacity(), 0);
assert_eq!(filtered.denoise.capacity(), 1);
let expected = 169 * 80 + std::mem::size_of::<super::super::denoise::Guides>() as u64 + std::mem::size_of::<job::output::OutputTask>() as u64;
assert_eq!(filtered.admission.estimated_total_bytes - plain.admission.estimated_total_bytes, expected);
let output = Some(job::OutputOptions { linear_exr: true, ..Default::default() });
let plain = denoised_plane(4, false, output);
let filtered = denoised_plane(4, true, output);
assert_eq!(
filtered.admission.estimated_total_bytes - plain.admission.estimated_total_bytes,
169 * 64 + std::mem::size_of::<super::super::denoise::Guides>() as u64
);
let mut request = plain.request.clone();
request.width = 8193;
request.height = 1;
let options = RaytraceOptions { denoise: true, budget: job::CpuBudget::Workstation, ..Default::default() };
request.raytrace = Some(options.clone());
assert!(admit(&plain.scene, &request, &options).unwrap_err().message.contains("CPU denoising"));
}
#[test]
fn cpu_denoising_guides_and_filter_keep_cancellation_and_cumulative_work() {
for guide_stage in [true, false] {
for cancel in [true, false] {
let mut task = denoised_plane(2, true, Some(job::OutputOptions { linear_exr: true, ..Default::default() }));
for _ in 0..300000 {
let reached = if guide_stage {
task.bvh.is_some() && task.denoise.first().is_some_and(|g| !g.ready())
} else {
task.output.first().is_some_and(|o| o.stage_name() == "denoise")
};
if reached {
break;
}
assert!(!matches!(task.step_with_previews(1).unwrap(), ImagePoll::Complete(_)));
}
if guide_stage {
assert!(!task.denoise.first().unwrap().ready())
} else {
assert_eq!(task.output.first().unwrap().stage_name(), "denoise")
}
if cancel {
task.cancel.cancel()
} else {
task.work.limit = task.work.used()
}
assert_eq!(task.step_with_previews(1).err().unwrap().code, if cancel { ErrorCode::Cancelled } else { ErrorCode::LimitExceeded });
assert!(!task.done);
assert!(task.take_linear_exr().is_none());
}
}
}
fn actual_denoise_guides(mut task: ImageTask) -> Vec<job::denoise::Guide> {
for _ in 0..300000 {
if task.denoise.first().is_some_and(|guides| guides.ready()) {
assert_eq!(task.pixel, 0, "guide construction cannot consume a Monte Carlo sample");
assert_eq!(task.progressive.as_ref().unwrap().film.samples(), 0);
return task.denoise.first().unwrap().pixels().unwrap().to_vec();
}
assert!(!matches!(task.step_with_previews(1).unwrap(), ImagePoll::Complete(_)));
}
panic!("bounded production guides did not finish")
}
#[test]
fn cpu_denoise_production_guides_use_exact_body_and_material_bypass_policy() {
for case in 0..7 {
let base = denoised_plane(2, true, None);
let mut source = base.scene.clone();
let mut options = base.options.clone();
match case {
0 | 1 => {
for body in &mut source.meshes {
body.surface = Some(OpaqueSurface::new(Vec3::new(0.4, 0.6, 0.8), 1.0, if case == 0 { 0.2 } else { 0.3 }, 1.5).unwrap());
}
}
2 | 3 => {
for body in &mut source.meshes {
body.surface = Some(
OpaqueSurface::new(Vec3::new(0.4, 0.6, 0.8), 0.0, 0.5, 1.5)
.unwrap()
.with_clear_coat(crate::clear_coat::ClearCoat::new(1.0, if case == 2 { 0.045 } else { 0.1 }, 1.5).unwrap()),
);
}
}
4 => {
options.dielectrics = source
.meshes
.iter()
.enumerate()
.map(|(body_index, body)| job::DielectricOptions {
model: None,
shadow_transmission: false,
subsurface: None,
body_index,
body_name: body.name.clone(),
boundary: job::DielectricBoundary::ThinSheet,
ior: 1.5,
absorption_per_mm: [0.0; 3],
thickness_mm: 0.0,
})
.collect();
}
5 => {
options.reflections = Some(job::ReflectionOptions {
samples: 1,
bodies: source
.meshes
.iter()
.map(|body| job::ReflectionBody { body: body.name.clone(), mode: job::ReflectionMode::Mirror })
.collect(),
..Default::default()
})
}
_ => {
options.emissions = Some(
source
.meshes
.iter()
.enumerate()
.map(|(body_index, body)| job::SurfaceEmission {
body_index,
body: body.name.clone(),
color: [1.0; 3],
strength: 1.0,
sides: job::EmissionSides::Both,
})
.collect(),
)
}
}
let request = ImageRequest { raytrace: Some(options.clone()), ..base.request.clone() };
let guides = actual_denoise_guides(ImageTask::new(source, request, CancelToken::default(), options).unwrap());
let eligible = matches!(case, 1 | 3);
assert!(guides.iter().all(|g| (g.body != 0) == eligible), "case {case}");
if eligible {
assert!(guides.iter().all(|g| g.body == 1 || g.body == 2));
assert!(guides.iter().all(|g| g.albedo == [0.4, 0.6, 0.8]));
}
}
}
#[test]
fn cpu_denoise_center_guides_are_translation_stable_and_independent_of_pupil_sampling() {
let base = denoised_plane(2, true, None);
let expected = actual_denoise_guides(denoised_plane(2, true, None));
let shift = Vec3::new(9e8, -8e8, 7e8);
let mut scene = base.scene.clone();
for body in &mut scene.meshes {
let mut mesh = (*body.mesh).clone();
for position in &mut mesh.positions {
*position += shift;
}
body.mesh = std::sync::Arc::new(mesh);
}
scene.bounds = scene.meshes.iter().fold(Aabb3::EMPTY, |bounds, body| bounds.union(&body.mesh.bounds()));
let mut request = base.request.clone();
request.camera.target += shift;
let translated = actual_denoise_guides(ImageTask::new(scene, request, CancelToken::default(), base.options.clone()).unwrap());
for (a, b) in expected.iter().zip(translated) {
assert_eq!((a.body, a.albedo, a.normal), (b.body, b.albedo, b.normal));
for i in 0..3 {
assert!((a.position[i] - b.position[i]).abs() < 1e-4);
}
assert!((a.depth - b.depth).abs() < 1e-4);
assert_eq!(a.footprint, b.footprint);
}
let mut request = base.request.clone();
request.camera.fov = 0.8;
let no_lens = actual_denoise_guides(ImageTask::new(base.scene.clone(), request.clone(), CancelToken::default(), base.options.clone()).unwrap());
let mut options = base.options.clone();
options.lens = Some(job::ThinLens { aperture_radius_mm: 0.2, focus_distance_mm: 25.0 });
request.raytrace = Some(options.clone());
let lens = actual_denoise_guides(ImageTask::new(base.scene.clone(), request, CancelToken::default(), options).unwrap());
for (a, b) in no_lens.iter().zip(lens) {
assert_eq!((a.body, a.albedo, a.normal, a.position, a.depth, a.footprint), (b.body, b.albedo, b.normal, b.position, b.depth, b.footprint));
}
}
#[test]
fn cpu_denoising_rejects_invalid_raw_radiance_and_never_masks_it_with_bypass() {
for body in [0, 1] {
let mut guide = denoise_test_guide(0, 0);
guide.body = body;
for pixel in [[f32::NAN, 0.0, 0.0, 1.0], [f32::INFINITY, 0.0, 0.0, 1.0], [-1.0, 0.0, 0.0, 1.0], [0.0, 0.0, 0.0, 1.1]] {
let mut task = job::denoise::DenoiseTask::new(1, 1, vec![pixel]).unwrap();
assert!(task.step(&[guide], &CancelToken::default()).is_err());
}
}
let cancel = CancelToken::default();
cancel.cancel();
let mut task = job::denoise::DenoiseTask::new(1, 1, vec![[1.0; 4]]).unwrap();
assert_eq!(task.step(&[denoise_test_guide(0, 0)], &cancel).unwrap_err().code, ErrorCode::Cancelled);
}
#[test]
fn cpu_denoise_hit_and_miss_guide_continuations_charge_one_unit_before_each_store() {
for miss in [false, true] {
for exhaust_at_store in [false, true] {
let base = denoised_plane(2, true, None);
let source = if miss { ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY } } else { base.scene.clone() };
let mut task = ImageTask::new(source, base.request.clone(), CancelToken::default(), base.options.clone()).unwrap();
let mut guide_calls = 0;
let mut tested_store = false;
for _ in 0..300000 {
if task.bvh.is_some() && task.denoise.first().is_some_and(|guides| !guides.ready()) {
let guide = task.denoise.first().unwrap();
let stored = guide.completed_pixels();
let at_store = guide.ready_to_store(&task.options);
let before = task.work.used();
if exhaust_at_store && at_store {
task.work.limit = before;
assert_eq!(task.step_with_previews(1).err().unwrap().code, ErrorCode::LimitExceeded);
assert_eq!(task.work.used(), before);
let guide = task.denoise.first().unwrap();
assert_eq!(guide.completed_pixels(), stored);
assert!(guide.ready_to_store(&task.options), "an exhausted debit cannot consume the pending guide");
assert_eq!(task.progressive.as_ref().unwrap().film.samples(), 0);
assert!(task.take_linear_exr().is_none());
tested_store = true;
break;
}
assert!(matches!(task.step_with_previews(1).unwrap(), ImagePoll::Pending(_)));
assert_eq!(task.work.used() - before, 1, "one guide call; miss={miss}, store={at_store}");
guide_calls += 1;
if task.denoise.first().unwrap().ready() {
break;
}
} else {
assert!(!matches!(task.step_with_previews(1).unwrap(), ImagePoll::Complete(_)));
}
}
assert!(guide_calls > 0);
if exhaust_at_store {
assert!(tested_store);
} else {
let guides = task.denoise.first().unwrap();
assert!(guides.ready());
assert_eq!(guides.completed_pixels(), 169);
assert!(guides.pixels().unwrap().iter().all(|guide| (guide.body == 0) == miss));
assert_eq!(task.progressive.as_ref().unwrap().film.samples(), 0);
}
}
}
}
#[test]
fn adaptive_certified_optics_drain_pilot_branches_and_keep_exact_independent_production_beer_energy() {
use crate::job::adaptive::AdaptiveSampling;
for thin in [false, true] {
for ior in [1.0, 1.5] {
let build = || {
let original = progressive_optics_fixture(16, thin, ior, CancelToken::default());
let options = RaytraceOptions {
adaptive: Some(Box::new(AdaptiveSampling { pilot_samples: 16, min_samples: 16, ..Default::default() })),
..original.options
};
let request = ImageRequest { raytrace: Some(options.clone()), ..original.request };
ImageTask::new(original.scene, request, CancelToken::default(), options).unwrap()
};
let actual = progressive_optics_complete(build(), 1);
assert_eq!(actual, progressive_optics_complete(build(), 16384));
assert_eq!(actual.0.iter().map(|p| p.0).collect::<Vec<_>>(), (1..32).collect::<Vec<_>>());
let production = progressive_optics_complete(progressive_optics_fixture(16, thin, ior, CancelToken::default()), 3);
assert_eq!(actual.1, production.1, "discarded pilots cannot alter the existing16-sample production optical estimator");
if ior == 1.0 {
let mapped = map_to_display(Vec3::new((-0.8_f64).exp(), (-1.6_f64).exp(), 1.0), 0.0).unwrap();
let expected = [encode8(mapped.x), encode8(mapped.y), encode8(mapped.z), 255];
for (_, png) in actual.0.iter().chain(std::iter::once(&(32, actual.1.clone()))) {
assert_eq!(
::image::load_from_memory(png).unwrap().to_rgba8().get_pixel(0, 0).0,
expected,
"all pilot/production prefixes retain the independent8mm Beer oracle"
);
}
}
}
}
}
#[test]
fn prepaid_legacy_certificate_and_standalone_cursor_share_cumulative_work_and_exact_output() {
let scene = dielectric::tests::scene(dielectric::tests::box_body(2.0));
let options = RaytraceOptions {
dielectrics: vec![dielectric::tests::input(job::DielectricBoundary::ClosedBox)],
lights: Some(Vec::new()),
environment: Some(job::RaytraceEnvironmentOptions { color: [1.0; 3], intensity: 1.0 }),
output: Some(Box::new(job::OutputOptions { linear_exr: true, ..Default::default() })),
..Default::default()
};
let request = dielectric::tests::request(options.clone());
let cancel = CancelToken::default();
let proof = certify_for_request(&scene, &request, &options, &cancel).unwrap().unwrap();
let prepared_work = proof.work_used();
assert!(prepared_work > 12, "the complete tiled-boundary proof is real work");
let mut prepared = ImageTask::new_prepared(scene.clone(), request.clone(), cancel, options.clone(), None, Some(proof)).unwrap();
let mut standalone = ImageTask::new(scene, request, CancelToken::default(), options).unwrap();
assert!(prepared.optical[0].preparation.is_empty(), "the factory consumes the proof instead of certifying again");
assert!(!standalone.optical[0].preparation.is_empty());
assert_eq!(prepared.work.used(), prepared_work);
while !standalone.optical[0].preparation.is_empty() {
let before = standalone.work.used();
assert!(matches!(standalone.step(1).unwrap(), TaskPoll::Pending(_)));
assert_eq!(standalone.work.used() - before, 1);
assert!(standalone.triangles.is_empty() && standalone.pixels.is_empty(), "proof precedes geometry/pixels");
}
assert_eq!(standalone.work.used(), prepared.work.used(), "background proof/store credit transfers into the one cumulative budget");
let complete = |task: &mut ImageTask| {
for _ in 0..100_000 {
if let TaskPoll::Complete(png) = task.step(1).unwrap() {
return png;
}
}
panic!("tiny certified image did not complete");
};
let a = complete(&mut prepared);
let b = complete(&mut standalone);
assert_eq!(a, b);
let raw = prepared.take_linear_exr().expect("final raw EXR");
assert_eq!(Some(raw.as_slice()), standalone.take_linear_exr().as_deref(), "prepared proof does not alter raw master bytes");
assert_eq!(prepared.work.used(), standalone.work.used());
// Independent native uncompressed FLOAT EXR scanline: one1×1 chunk stores
// the four A/B/G/R channels, all exactly1 for this lossless white furnace.
assert_eq!(&raw[..8], &[0x76, 0x2f, 0x31, 0x01, 2, 0, 0, 0]);
let mut header = 8;
while raw[header] != 0 {
header += raw[header..].iter().position(|byte| *byte == 0).unwrap() + 1;
header += raw[header..].iter().position(|byte| *byte == 0).unwrap() + 1;
let count = u32::from_le_bytes(raw[header..header + 4].try_into().unwrap()) as usize;
header += 4 + count;
}
header += 1;
let chunk = u64::from_le_bytes(raw[header..header + 8].try_into().unwrap()) as usize;
assert_eq!(chunk, header + 8);
assert_eq!(i32::from_le_bytes(raw[chunk..chunk + 4].try_into().unwrap()), 0);
assert_eq!(u32::from_le_bytes(raw[chunk + 4..chunk + 8].try_into().unwrap()), 16);
let channels: [f32; 4] = std::array::from_fn(|i| f32::from_le_bytes(raw[chunk + 8 + i * 4..chunk + 12 + i * 4].try_into().unwrap()));
assert_eq!(channels, [1.0; 4], "lossless raw radiance/coverage remains exactly1 before presentation");
// Default Reinhard maps linear1 to.5; standard sRGB encoding rounds to188.
assert_eq!(
::image::load_from_memory(&a).unwrap().to_rgba8().get_pixel(0, 0).0,
[188, 188, 188, 255],
"white furnace follows the existing presentation contract"
);
}
#[test]
fn standalone_legacy_preparation_cancellation_never_advances_or_allocates_pixels() {
let scene = dielectric::tests::scene(dielectric::tests::box_body(2.0));
let options = RaytraceOptions { dielectrics: vec![dielectric::tests::input(job::DielectricBoundary::ClosedBox)], ..Default::default() };
let request = dielectric::tests::request(options.clone());
let cancel = CancelToken::default();
let mut task = ImageTask::new(scene, request, cancel.clone(), options).unwrap();
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
let before = (task.work.used(), task.optical[0].preparation.len(), task.triangles.len(), task.pixels.len());
cancel.cancel();
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
assert_eq!((task.work.used(), task.optical[0].preparation.len(), task.triangles.len(), task.pixels.len()), before);
}
fn mapped_wood_fixture() -> (ProductScene, ImageRequest, RaytraceOptions) {
use crate::job::textures::{BaseColorMode, PlanarFrame, RuntimeTextures, TextureBinding, TextureMap};
use image::ImageEncoder;
use std::sync::Arc;
let mesh = solidcraft_geom::Mesh {
positions: vec![Vec3::new(-40., -40., 0.), Vec3::new(40., -40., 0.), Vec3::new(40., 40., 0.), Vec3::new(-40., 40., 0.)],
normals: vec![Vec3::Z; 4],
triangles: vec![[0, 1, 2], [0, 2, 3]],
tri_face: vec![0, 0],
..Default::default()
};
let bounds = mesh.bounds();
let surface = OpaqueSurface::new(Vec3::new(1., 1., 1.), 0., 0.7, 1.).unwrap();
let scene = ProductScene {
bounds,
meshes: vec![crate::ProductMesh {
name: "Wood board".into(),
mesh: Arc::new(mesh),
color: [255; 3],
opacity: 1.,
surface: Some(surface),
transmission: None,
faces: vec![],
}],
};
// Original diagnostic grain: alternating opaque dark/light fibres with known mean.
let mut encoded = Vec::new();
let pixels: Vec<u8> = (0..64)
.flat_map(|i| {
let value = if i % 8 % 2 == 0 { 0 } else { 255 };
[value, value, value, 255]
})
.collect();
image::codecs::png::PngEncoder::new(&mut encoded).write_image(&pixels, 8, 8, image::ExtendedColorType::Rgba8).unwrap();
let textures = RuntimeTextures::new(vec![TextureBinding {
body_index: 0,
body_name: "Wood board".into(),
frame: PlanarFrame { origin: [0.; 3], u: [1., 0., 0.], v: [0., 1., 0.] },
normal_strength: 0.4,
base_color: Some(TextureMap::new(encoded, crate::texture_input::MapRole::BaseColor).unwrap()),
normal: None,
roughness: None,
metallic: None,
base_color_mode: BaseColorMode::Replace,
flip_v: false,
}])
.unwrap();
let mut request = request();
request.camera.set_view(crate::StandardView::Top);
request.camera.distance = 1.25;
request.textures = Some(Arc::new(textures));
let options = RaytraceOptions {
lights: Some(vec![job::DirectionalLightOptions { direction: [0., 0., 1.], color: [1.; 3], intensity: std::f64::consts::PI }]),
shadows: false,
..Default::default()
};
request.raytrace = Some(options.clone());
(scene, request, options)
}
fn mapped_png(scene: ProductScene, request: ImageRequest, options: RaytraceOptions, quantum: usize) -> Vec<u8> {
let mut task = ImageTask::new(scene, request, CancelToken::default(), options).unwrap();
for _ in 0..300_000 {
let before = task.work.used();
let result = task.step(quantum).unwrap();
// Four bounded continuations; a PNG row keeps its legacy explicit row cost.
if let TaskPoll::Complete(png) = result {
return png;
}
assert!(task.work.used() >= before);
}
panic!("mapped image did not finish");
}
#[test]
fn cpu_wood_keeps_close_fibres_and_minifies_distant_fibres_to_the_linear_mean() {
let (scene, mut request, options) = mapped_wood_fixture();
let mesh = scene.meshes[0].mesh.clone();
let close = mapped_png(scene.clone(), request.clone(), options.clone(), 1);
assert_eq!(close, mapped_png(scene.clone(), request.clone(), options.clone(), 7));
let image = image::load_from_memory(&close).unwrap().to_rgba8();
let values: Vec<_> = image.pixels().map(|p| p[0]).collect();
assert!(values.iter().max().unwrap() - values.iter().min().unwrap() > 150, "magnified fibres must remain distinct: {values:?}");
request.camera.distance = 25.;
let far = mapped_png(scene.clone(), request.clone(), options.clone(), 7);
let image = image::load_from_memory(&far).unwrap().to_rgba8();
// Linear mean reflectance is 0.5. Unit irradiance/pi yields 0.5 radiance,
// then the existing Reinhard presentation maps 0.5 to 1/3 before sRGB.
let expected = encode8(1. / 3.);
assert!(image.pixels().all(|p| p.0 == [expected, expected, expected, 255]), "distant grain must converge to linear-light mean");
assert!(std::sync::Arc::ptr_eq(&mesh, &scene.meshes[0].mesh));
assert_eq!(scene.meshes[0].surface.unwrap().dielectric_ior(), 1.);
}
#[test]
fn cpu_wood_scalar_face_override_suppresses_inherited_body_maps() {
let (mut scene, mut request, options) = mapped_wood_fixture();
scene.meshes[0].faces.push(crate::FaceAppearance {
face: 0,
color: [64, 96, 128],
opacity: 1.,
surface: Some(OpaqueSurface::new(Vec3::new(0.2, 0.3, 0.4), 0., 0.7, 1.).unwrap()),
transmission: None,
});
let mapped = mapped_png(scene.clone(), request.clone(), options.clone(), 1);
request.textures = None;
assert_eq!(mapped, mapped_png(scene, request, options, 7));
}
#[test]
fn cpu_wood_footprint_uses_unwrapped_physical_spacing_and_applies_supersampling_once() {
let (_, request, mut options) = mapped_wood_fixture();
let clip = request.camera.clip(100.);
let ray = primary_ray(&request, 0.5, 0.5, clip).unwrap();
let point = ray.origin() + ray.direction() * (-ray.origin().z / ray.direction().z);
let first = primary_footprint(&request, &options, None, 0, 0, clip, point, Vec3::Z).unwrap().unwrap();
assert!((first[0].len() - 0.125).abs() < 1e-12);
assert!((first[1].len() - 0.125).abs() < 1e-12);
for samples in [4, 16] {
options.primary_samples = samples;
let offset = primary_offset(samples, 0).unwrap();
let ray = primary_ray(&request, offset[0], offset[1], clip).unwrap();
let p = ray.origin() + ray.direction() * (-ray.origin().z / ray.direction().z);
let footprint = primary_footprint(&request, &options, None, 0, 0, clip, p, Vec3::Z).unwrap().unwrap();
for delta in footprint {
assert!((delta.len() - 0.125 / f64::from(samples).sqrt()).abs() < 1e-12);
}
}
}
#[test]
fn thin_lens_map_footprint_holds_the_sampled_pupil_on_off_focus_planes() {
let (scene, mut request, mut options) = mapped_wood_fixture();
request.width = 64;
request.height = 32;
request.camera.distance = 10.0;
request.camera.fov = std::f64::consts::FRAC_PI_2;
options.progressive = Some(job::CpuProgressiveOptions { samples_per_pixel: 2, seed: 81 });
for focus_distance_mm in [5.0, 20.0] {
let lens = job::ThinLens { aperture_radius_mm: 0.8, focus_distance_mm };
options.lens = Some(lens);
request.raytrace = Some(options.clone());
let task = ImageTask::new(scene.clone(), request.clone(), CancelToken::default(), options.clone()).unwrap();
let progressive = task.progressive.as_ref().unwrap();
let (right, up, back) = request.camera.basis();
let plane = request.camera.target;
let depth = request.camera.distance;
// On a frontoparallel plane a fixed pupil translates every hit equally.
// One output-pixel differential is 2*depth*tan(fov/2)/height, regardless
// of focus distance or pupil position. This is an analytic scale oracle.
let expected = 2.0 * depth * (request.camera.fov * 0.5).tan() / f64::from(request.height);
for pixel in [0, 37, 1024, 2047] {
let [dx, dy] = progressive.variates(pixel, 0).unwrap();
let pupil = progressive.variates(pixel, 0x4c454e53).unwrap();
let x = (pixel % request.width as usize) as f64 + dx;
let y = (pixel / request.width as usize) as f64 + dy;
let hit = |ray: Ray| ray.origin() + ray.direction() * ((plane - ray.origin()).dot(back) / ray.direction().dot(back));
let point = hit(lens_primary_ray(&request, x, y, task.clip, lens, pupil).unwrap());
let pinhole = hit(primary_ray(&request, x, y, task.clip).unwrap());
assert!((point - pinhole).len() > 1e-6, "the fixture must expose off-focus pupil parallax");
let footprint = primary_footprint(&request, &options, Some(progressive), pixel, 0, task.clip, point, back).unwrap().unwrap();
assert!((footprint[0] - right * expected).len() < 1e-10, "horizontal footprint must hold the sampled pupil");
assert!((footprint[1] + up * expected).len() < 1e-10, "vertical footprint must hold the sampled pupil");
assert_eq!(progressive.variates(pixel, 0).unwrap(), [dx, dy]);
assert_eq!(progressive.variates(pixel, 0x4c454e53).unwrap(), pupil);
let mut zero = options.clone();
zero.lens = Some(job::ThinLens { aperture_radius_mm: 0.0, focus_distance_mm });
assert_eq!(
primary_footprint(&request, &zero, Some(progressive), pixel, 0, task.clip, pinhole, back).unwrap(),
camera_footprint(&request, x, y, 1.0, task.clip, pinhole, back).unwrap(),
"zero aperture keeps the existing pinhole footprint exactly"
);
}
}
}
#[test]
fn cpu_wood_preparation_cancel_and_role_work_limit_never_publish_partial_pixels() {
let (scene, request, options) = mapped_wood_fixture();
let cancel = CancelToken::default();
let mut task = ImageTask::new(scene, request, cancel.clone(), options).unwrap();
let cache = task.maps.first().unwrap();
assert!(!cache.ready());
assert_eq!(cache.prepared_maps(), 0);
assert_eq!(cache.preparation_phase(), None);
for _ in 0..100_000 {
if task.maps.first().is_some_and(|cache| cache.hit_role() == Some(1)) {
break;
}
assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
}
assert_eq!(task.maps.first().unwrap().prepared_maps(), 1);
assert_eq!(task.maps.first().unwrap().hit_role(), Some(1));
assert!(task.pixels.is_empty());
task.work.limit = task.work.used();
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::LimitExceeded);
assert_eq!(task.maps.first().unwrap().hit_role(), Some(1));
cancel.cancel();
assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
assert!(!task.done);
}