2aa45ef3ee
Each path test opens its own device and compiles the path pipeline. On a cold driver cache that takes minutes and gigabytes per compile, and libtest ran one per CPU thread side by side: on NVIDIA the solidcraft-gpu tests ran for hours and committed ~80 GB. Executor::new now holds a process-wide lock while it compiles; the first compile fills the driver's cache and the waiting ones get the pipeline from there. Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
3424 lines
163 KiB
Rust
3424 lines
163 KiB
Rust
use super::*;
|
|
use solidcraft_geom::prelude::*;
|
|
use solidcraft_geom::{Aabb3, Mesh};
|
|
use solidcraft_render::{Camera, ProductMesh, StandardView, surface::OpaqueSurface};
|
|
|
|
fn executor() -> Option<Executor> {
|
|
let (adapter, device, queue) = match open_headless() {
|
|
Ok(device) => device,
|
|
Err(e) => {
|
|
// The path tracer runs on Vulkan or Metal only: where the backends in use leave both out
|
|
// (`WGPU_BACKEND=dx12`), it is unavailable by design, not missing.
|
|
let available = !crate::select::path_backends().is_empty();
|
|
assert!(!available || std::env::var_os("SOLIDCRAFT_REQUIRE_GPU").is_none(), "required GPU unavailable: {e}");
|
|
eprintln!("gpu-path device test skipped: {e}");
|
|
return None;
|
|
}
|
|
};
|
|
eprintln!("gpu-path tests on {} ({:?}, {:?})", adapter.get_info().name, adapter.get_info().device_type, adapter.get_info().backend);
|
|
Some(Executor::new(device, queue).unwrap())
|
|
}
|
|
fn request(size: u32) -> ImageRequest {
|
|
let mut camera = Camera { distance: 4.0, ..Default::default() };
|
|
camera.set_view(StandardView::Top);
|
|
ImageRequest {
|
|
studio_weights: None,
|
|
integrator: Default::default(),
|
|
raytrace: None,
|
|
textures: None,
|
|
environment: None,
|
|
camera,
|
|
width: size,
|
|
height: size,
|
|
background: [10, 20, 30],
|
|
transparent_background: false,
|
|
}
|
|
}
|
|
fn sphere(surface: OpaqueSurface) -> ProductScene {
|
|
sphere_grid(surface, 48, 96)
|
|
}
|
|
fn sphere_grid(surface: OpaqueSurface, rows: u32, columns: u32) -> ProductScene {
|
|
sphere_section(surface, rows, columns, rows)
|
|
}
|
|
fn sphere_section(surface: OpaqueSurface, rows: u32, columns: u32, rings: u32) -> ProductScene {
|
|
// Original unit sphere, deliberately triangulated here rather than imported test data.
|
|
let mut mesh = Mesh::default();
|
|
for i in 0..=rings {
|
|
let theta = f64::from(i) * std::f64::consts::PI / f64::from(rows);
|
|
for j in 0..=columns {
|
|
let phi = f64::from(j) * std::f64::consts::TAU / f64::from(columns);
|
|
let n = Vec3::new(theta.sin() * phi.cos(), theta.sin() * phi.sin(), theta.cos());
|
|
mesh.positions.push(n);
|
|
mesh.normals.push(n);
|
|
}
|
|
}
|
|
for i in 0..rings {
|
|
for j in 0..columns {
|
|
let a = i * (columns + 1) + j;
|
|
let b = a + columns + 1;
|
|
mesh.triangles.extend([[a, b, a + 1], [a + 1, b, b + 1]]);
|
|
mesh.tri_face.extend([0, 0]);
|
|
}
|
|
}
|
|
let bounds = mesh.bounds();
|
|
ProductScene {
|
|
meshes: vec![ProductMesh {
|
|
name: "original sphere".into(),
|
|
mesh: Arc::new(mesh),
|
|
color: [255; 3],
|
|
opacity: 1.0,
|
|
surface: Some(surface),
|
|
transmission: None,
|
|
faces: Vec::new(),
|
|
}],
|
|
bounds,
|
|
}
|
|
}
|
|
fn white() -> OpaqueSurface {
|
|
OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 0.0, 1.0, 1.0).unwrap()
|
|
}
|
|
|
|
fn clear_glass() -> solidcraft_render::transmission::Transmission {
|
|
solidcraft_render::transmission::Transmission::new(Vec3::ZERO, None).unwrap()
|
|
}
|
|
|
|
#[test]
|
|
fn volume_glass_requires_closed_outward_homogeneous_geometry() {
|
|
let mut glass = sphere(OpaqueSurface::new(Vec3::ZERO, 0.0, 0.1, 1.5).unwrap());
|
|
glass.meshes[0].transmission = Some(clear_glass());
|
|
assert!(scene::flatten(&glass, Vec3::ZERO, &CancelToken::default()).is_ok());
|
|
let mut open = glass.clone();
|
|
let mesh = Arc::make_mut(&mut open.meshes[0].mesh);
|
|
mesh.triangles.remove(300);
|
|
mesh.tri_face.remove(300);
|
|
assert!(scene::flatten(&open, Vec3::ZERO, &CancelToken::default()).is_err());
|
|
let mut inward = glass;
|
|
for t in &mut Arc::make_mut(&mut inward.meshes[0].mesh).triangles {
|
|
t.swap(1, 2);
|
|
}
|
|
assert!(scene::flatten(&inward, Vec3::ZERO, &CancelToken::default()).is_err());
|
|
open.meshes[0].transmission = Some(solidcraft_render::transmission::Transmission::new(Vec3::ZERO, Some(0.1)).unwrap());
|
|
assert!(scene::flatten(&open, Vec3::ZERO, &CancelToken::default()).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn nested_and_overlapping_dielectric_bounds_are_rejected_before_upload() {
|
|
let mut outer = sphere(OpaqueSurface::new(Vec3::ZERO, 0.0, 0.1, 1.5).unwrap());
|
|
outer.meshes[0].transmission = Some(clear_glass());
|
|
for shift in [0.0, 0.5] {
|
|
let mut inner = outer.meshes[0].clone();
|
|
for p in &mut Arc::make_mut(&mut inner.mesh).positions {
|
|
*p = *p * 0.5 + Vec3::new(shift, 0.0, 0.0);
|
|
}
|
|
let mut scene = outer.clone();
|
|
scene.meshes.push(inner);
|
|
assert!(scene::flatten(&scene, Vec3::ZERO, &CancelToken::default()).is_err());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn multiple_closed_shells_in_one_dielectric_body_are_rejected() {
|
|
let mut scene = sphere(OpaqueSurface::new(Vec3::ZERO, 0.0, 0.1, 1.5).unwrap());
|
|
scene.meshes[0].transmission = Some(clear_glass());
|
|
let second = scene.meshes[0].mesh.clone();
|
|
let mesh = Arc::make_mut(&mut scene.meshes[0].mesh);
|
|
let offset = mesh.positions.len() as u32;
|
|
mesh.positions.extend(second.positions.iter().map(|p| *p + Vec3::new(4.0, 0.0, 0.0)));
|
|
mesh.normals.extend(&second.normals);
|
|
mesh.triangles.extend(second.triangles.iter().map(|t| t.map(|i| i + offset)));
|
|
mesh.tri_face.extend(&second.tri_face);
|
|
let error = scene::flatten(&scene, Vec3::ZERO, &CancelToken::default()).err().unwrap();
|
|
assert!(error.to_string().contains("one connected shell"), "{error}");
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_exact_dielectric_matches_f64_fresnel() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor { label: None, source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("dielectric_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
let mut task = Task::new(context.clone(), sphere(white()), request(1), JobOptions::default(), CancelToken::default()).unwrap();
|
|
for (ni, nt) in [(1.0_f64, 1.0_f64), (1.0, 1.5), (1.5, 1.0), (1.0, 3.0)] {
|
|
for cosine in [0.0, 0.01, 0.5, (nt / ni).atan().cos(), 1.0] {
|
|
let mut params = vec![0; 64];
|
|
scene::vector(&mut params, Vec3::new(cosine, ni, nt), 0.0);
|
|
params.resize(PARAMETER_BYTES, 0);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let actual = task.read_linear().unwrap()[0];
|
|
let expected = solidcraft_render::transmission::fresnel(cosine, ni, nt).unwrap();
|
|
for (a, b) in actual.iter().zip([expected.s, expected.p, expected.transmitted_cosine.unwrap_or(0.0)]) {
|
|
assert!((f64::from(*a) - b).abs() < 2e-5, "Fresnel {ni}->{nt} cos={cosine}: {a} != {b}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_nonabsorbing_glass_sphere_white_furnace_conserves_radiance() {
|
|
let Some(executor) = executor() else { return };
|
|
let mut scene = sphere(OpaqueSurface::new(Vec3::ZERO, 0.0, 0.1, 1.5).unwrap());
|
|
scene.meshes[0].transmission = Some(clear_glass());
|
|
scene.meshes[0].opacity = 0.2;
|
|
let options = JobOptions { samples: 512, max_depth: 16, seed: 1948, ..Default::default() };
|
|
let mut task = Task::new(executor.context.clone(), scene, request(16), options, CancelToken::default()).unwrap();
|
|
task.environment = 1.0;
|
|
task.studio = 0.0;
|
|
for _ in 0..options.samples {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
for (index, pixel) in task.read_linear().unwrap().iter().enumerate() {
|
|
assert!((pixel[0] - 1.0).abs() < 0.025, "glass furnace pixel {index}: {pixel:?}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_ball_lens_focus_uses_actual_mesh_intersections() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor { label: None, source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("lens_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
let mut scene = sphere_grid(OpaqueSurface::new(Vec3::ZERO, 0.0, 0.1, 1.5).unwrap(), 128, 256);
|
|
scene.meshes[0].transmission = Some(clear_glass());
|
|
let mut task = Task::new(context.clone(), scene, request(1), JobOptions::default(), CancelToken::default()).unwrap();
|
|
for height in [0.01, 0.02, 0.03] {
|
|
let mut params = vec![0; 32];
|
|
scene::vector(&mut params, Vec3::new(height, 0.0, 3.0), 0.0);
|
|
scene::vector(&mut params, Vec3::ZERO, 0.0);
|
|
scene::vector(&mut params, Vec3::ZERO, 0.0);
|
|
scene::vector(&mut params, -Vec3::Z, 1.5); // nR/(2(n-1)), measured from centre.
|
|
scene::vector(&mut params, Vec3::new(f64::from(task.epsilon), 0.0, 0.0), 0.0);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let actual = task.read_linear().unwrap()[0];
|
|
assert_eq!(actual[3], 1.0);
|
|
assert!((actual[0] - 1.0).abs() < 5e-5 && (actual[1] - 1.0).abs() < 5e-5, "image-space focal spot at h={height}: {actual:?}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_camera_inside_volume_fails_without_publishing_fake_radiance() {
|
|
let Some(executor) = executor() else { return };
|
|
let mut scene = sphere(OpaqueSurface::new(Vec3::ZERO, 0.0, 0.1, 1.5).unwrap());
|
|
scene.meshes[0].transmission = Some(clear_glass());
|
|
let mut request = request(1);
|
|
request.camera.distance = 0.1;
|
|
let mut task = Task::new(executor.context.clone(), scene.clone(), request.clone(), JobOptions::default(), CancelToken::default()).unwrap();
|
|
task.complete_sample().unwrap();
|
|
assert_eq!(task.read_linear().unwrap_err().code, ErrorCode::InvalidScene);
|
|
drop(task);
|
|
// Seed just below the 32-bit wrap: the next real failed path must carry
|
|
// into the high word, rather than clearing diagnostics and publishing black.
|
|
let mut task = Task::new(executor.context.clone(), scene, request, JobOptions::default(), CancelToken::default()).unwrap();
|
|
let mut failures = [0; FAILURE_BYTES as usize];
|
|
failures[..4].copy_from_slice(&u32::MAX.to_le_bytes());
|
|
task.context.queue.write_buffer(&task.failures, 0, &failures);
|
|
task.complete_sample().unwrap();
|
|
let error = task.read_linear().unwrap_err();
|
|
assert_eq!(error.code, ErrorCode::InvalidScene);
|
|
assert!(error.message.contains("4294967296 of 1 paths"), "{error}");
|
|
}
|
|
|
|
#[test]
|
|
fn engine_preflight_keeps_cpu_alpha_and_routes_physical_glass_to_the_native_host() {
|
|
use serde_json::json;
|
|
let Some(executor) = executor() else { return };
|
|
let mut s = solidcraft_engine::Session::default();
|
|
s.set_render_job_host(Some(solidcraft_render::job::CpuHost::cooperative())).unwrap();
|
|
s.execute("solid.box", &json!({"length":10,"width":10,"height":2,"body_name":"Glass"})).unwrap();
|
|
s.execute("appearance.assign", &json!({"bodies":["Glass"],"color":"#c0e0ff","opacity":0.2})).unwrap();
|
|
let cpu = s.execute("render.preflight", &json!({"settings":{"width":16,"height":16}})).unwrap();
|
|
assert_eq!(cpu["refraction"], false);
|
|
assert_eq!(cpu["transparency"], "sorted_alpha_approximation");
|
|
assert!(s.execute("render.preflight", &json!({"progressive":true,"settings":{"width":16,"height":16}})).is_err());
|
|
s.register_render_job_host(ImageHost::with_executor(Arc::new(executor)).unwrap()).unwrap();
|
|
let snapshot = s.doc.to_json();
|
|
let mut params = json!({"progressive":true,"settings":{"width":16,"height":16},
|
|
"raytrace":{"dielectrics":[{"body_index":0,"body_name":"Glass","ior":1.5,"absorption_per_mm":[0.1,0.02,0],"boundary":"closed_box","thickness_mm":0}]}});
|
|
let gpu = s.execute("render.preflight", ¶ms).unwrap();
|
|
assert_eq!(gpu["refraction"], true);
|
|
assert_eq!(gpu["dielectric_boundaries"], json!(["thin_sheet", "closed_box", "closed_mesh"]));
|
|
assert_eq!(gpu["transparency"], "physical_transmission");
|
|
assert_eq!(gpu["resolved"]["executor"], "gpu-path");
|
|
params["settings"]["camera"] = json!(Camera { distance: 40.0, fov: 0.7, ..Default::default() });
|
|
params["lens"] = json!({"aperture_radius_mm":0.5,"focus_distance_mm":40});
|
|
let lens = s.execute("render.preflight", ¶ms).unwrap();
|
|
assert_eq!(lens["options"]["lens"]["aperture_radius_mm"], 0.5);
|
|
assert_eq!(snapshot, s.doc.to_json());
|
|
params["progressive"] = json!(false);
|
|
assert!(s.execute("render.preflight", ¶ms).is_err());
|
|
assert!(!solidcraft_engine::product_scene::extract(&s).unwrap().has_transmission());
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_thin_lens_focus_and_defocus_match_geometric_oracle() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor { label: None, source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("camera_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
for (yaw, pitch, roll) in [(0.0, 0.0, 0.0), (-0.45, 0.5, 0.7)] {
|
|
let mut request = request(2);
|
|
request.camera = Camera { distance: 12.0, fov: 0.7, yaw, pitch, roll, ..Default::default() };
|
|
let camera = request.camera;
|
|
let lens = solidcraft_render::job::ThinLens { aperture_radius_mm: 0.4, focus_distance_mm: 9.0 };
|
|
let options = JobOptions { lens: Some(lens), ..Default::default() };
|
|
let mut task = Task::new(context.clone(), sphere(white()), request, options, CancelToken::default()).unwrap();
|
|
let (right, up, back) = camera.basis();
|
|
let eye = back * camera.distance;
|
|
for (ux, uy) in [(0.0_f64, 0.0_f64), (0.7, -0.6)] {
|
|
let focal =
|
|
eye + (right * ux + up * uy) * (camera.half_height() * lens.focus_distance_mm / camera.distance) - back * lens.focus_distance_mm;
|
|
for (radial, azimuth) in [(0.0_f64, 0.0_f64), (0.25, 0.125), (0.75, 0.625), (0.999, 0.999)] {
|
|
let mut params = task.parameters(1);
|
|
params.truncate(96);
|
|
scene::vector(&mut params, Vec3::new(ux, uy, radial), azimuth as f32);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let rays = task.read_linear().unwrap();
|
|
let vec = |p: [f32; 4]| Vec3::new(f64::from(p[0]), f64::from(p[1]), f64::from(p[2]));
|
|
let origin = vec(rays[0]) - Vec3::new(16.0, 16.0, 16.0);
|
|
let direction = vec(rays[1]) - Vec3::new(2.0, 2.0, 2.0);
|
|
let disk = (right * (azimuth * std::f64::consts::TAU).cos() + up * (azimuth * std::f64::consts::TAU).sin())
|
|
* (radial.sqrt() * lens.aperture_radius_mm);
|
|
assert!((origin - eye - disk).len() < 3e-6);
|
|
let focus_hit = origin + direction * ((focal - origin).dot(back) / direction.dot(back));
|
|
assert!((focus_hit - focal).len() < 5e-6, "focus {focus_hit:?} != {focal:?}");
|
|
// At axial depth z, signed displacement from the pinhole hit is
|
|
// disk*(1-z/focus). Check both sides, including the flip beyond focus.
|
|
for depth in [4.5, 18.0] {
|
|
let centre = eye - back * depth;
|
|
let hit = origin + direction * ((centre - origin).dot(back) / direction.dot(back));
|
|
let pinhole = eye + (focal - eye) * (depth / lens.focus_distance_mm);
|
|
assert!((hit - pinhole - disk * (1.0 - depth / lens.focus_distance_mm)).len() < 1e-5);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_zero_aperture_is_bit_identical_and_lens_admission_is_explicit() {
|
|
let Some(executor) = executor() else { return };
|
|
let mut request = request(16);
|
|
request.camera.fov = 0.7;
|
|
let render = |lens, fov| {
|
|
let options = JobOptions { samples: 8, lens, seed: 1948, ..Default::default() };
|
|
let mut image = request.clone();
|
|
image.camera.fov = fov;
|
|
let mut task = Task::new(executor.context.clone(), sphere(white()), image, options, CancelToken::default()).unwrap();
|
|
for _ in 0..options.samples {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
task.read_linear().unwrap()
|
|
};
|
|
for fov in [0.0, 0.7] {
|
|
assert_eq!(render(None, fov), render(Some(solidcraft_render::job::ThinLens { aperture_radius_mm: 0.0, focus_distance_mm: 8.0 }), fov));
|
|
}
|
|
let lens = Some(solidcraft_render::job::ThinLens { aperture_radius_mm: 0.3, focus_distance_mm: 4.0 });
|
|
assert_eq!(render(lens, 0.7), render(lens, 0.7));
|
|
request.camera.fov = 0.0;
|
|
assert!(admission(&sphere(white()), &request, JobOptions { lens, ..Default::default() }).is_err());
|
|
request.camera.fov = 1e-100;
|
|
assert!(admission(&sphere(white()), &request, JobOptions { lens, ..Default::default() }).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "manual glass transport evidence; set SOLIDCRAFT_GLASS_EVIDENCE to a PNG path"]
|
|
fn glass_transport_evidence() {
|
|
let Some(executor) = executor() else { return };
|
|
let output = std::env::var("SOLIDCRAFT_GLASS_EVIDENCE").unwrap();
|
|
let mut meshes = Vec::new();
|
|
for (centre, radius, color) in
|
|
[(Vec3::new(-1.3, 0.0, 1.5), 1.5, Vec3::new(0.75, 0.94, 1.0)), (Vec3::new(2.0, 1.0, 1.0), 1.0, Vec3::new(1.0, 0.7, 0.35))]
|
|
{
|
|
let mut scene = sphere_grid(OpaqueSurface::new(Vec3::ZERO, 0.0, 0.1, 1.5).unwrap(), 96, 192);
|
|
let mut body = scene.meshes.remove(0);
|
|
for p in &mut Arc::make_mut(&mut body.mesh).positions {
|
|
*p = *p * radius + centre;
|
|
}
|
|
body.transmission =
|
|
Some(solidcraft_render::transmission::Transmission::new(Vec3::new(-color.x.ln(), -color.y.ln(), -color.z.ln()) / 5.0, None).unwrap());
|
|
meshes.push(body);
|
|
}
|
|
for y in -16..16 {
|
|
for x in -16..16 {
|
|
let color = if (x + y) % 2 == 0 { Vec3::new(0.65, 0.7, 0.75) } else { Vec3::new(0.035, 0.055, 0.08) };
|
|
let x = f64::from(x) * 2.0;
|
|
let y = f64::from(y) * 2.0;
|
|
let mesh = Mesh {
|
|
positions: vec![
|
|
Vec3::new(x, y, -0.01),
|
|
Vec3::new(x + 2.0, y, -0.01),
|
|
Vec3::new(x + 2.0, y + 2.0, -0.01),
|
|
Vec3::new(x, y + 2.0, -0.01),
|
|
],
|
|
normals: vec![Vec3::Z; 4],
|
|
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
|
tri_face: vec![0, 0],
|
|
..Default::default()
|
|
};
|
|
meshes.push(ProductMesh {
|
|
name: "original checker tile".into(),
|
|
mesh: Arc::new(mesh),
|
|
color: [200; 3],
|
|
opacity: 1.0,
|
|
surface: Some(OpaqueSurface::new(color, 0.0, 0.65, 1.5).unwrap()),
|
|
transmission: None,
|
|
faces: vec![],
|
|
});
|
|
}
|
|
}
|
|
let bounds = meshes.iter().fold(Aabb3::EMPTY, |a, m| a.union(&m.mesh.bounds()));
|
|
let camera = Camera { target: Vec3::new(0.0, 0.0, 1.0), yaw: -0.45, pitch: 0.5, distance: 13.0, fov: 0.65, ..Default::default() };
|
|
let request = ImageRequest {
|
|
studio_weights: None,
|
|
integrator: Default::default(),
|
|
raytrace: None,
|
|
textures: None,
|
|
environment: None,
|
|
camera,
|
|
width: 960,
|
|
height: 720,
|
|
background: [236, 240, 245],
|
|
transparent_background: false,
|
|
};
|
|
let lens =
|
|
std::env::var_os("SOLIDCRAFT_GLASS_DOF").map(|_| solidcraft_render::job::ThinLens { aperture_radius_mm: 0.5, focus_distance_mm: 12.0 });
|
|
let options = JobOptions { samples: 256, max_depth: 16, seed: 1948, lens, ..Default::default() };
|
|
let mut task = Task::new(executor.context.clone(), ProductScene { meshes, bounds }, request, options, CancelToken::default()).unwrap();
|
|
task.environment = 1.0;
|
|
loop {
|
|
if let TaskPoll::Complete(png) = task.step(4096).unwrap() {
|
|
std::fs::write(&output, png).unwrap();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn glass_slab(thin: bool) -> ProductScene {
|
|
let mut mesh = Mesh::default();
|
|
let faces = [
|
|
([[-10., -10., 0.5], [10., -10., 0.5], [10., 10., 0.5], [-10., 10., 0.5]], Vec3::Z),
|
|
([[-10., 10., -0.5], [10., 10., -0.5], [10., -10., -0.5], [-10., -10., -0.5]], -Vec3::Z),
|
|
([[10., -10., -0.5], [10., 10., -0.5], [10., 10., 0.5], [10., -10., 0.5]], Vec3::X),
|
|
([[-10., 10., -0.5], [-10., -10., -0.5], [-10., -10., 0.5], [-10., 10., 0.5]], -Vec3::X),
|
|
([[10., 10., -0.5], [-10., 10., -0.5], [-10., 10., 0.5], [10., 10., 0.5]], Vec3::Y),
|
|
([[-10., -10., -0.5], [10., -10., -0.5], [10., -10., 0.5], [-10., -10., 0.5]], -Vec3::Y),
|
|
];
|
|
for (index, (positions, normal)) in faces.into_iter().enumerate() {
|
|
if thin && index > 0 {
|
|
break;
|
|
}
|
|
let offset = mesh.positions.len() as u32;
|
|
for p in positions {
|
|
mesh.positions.push(Vec3::new(p[0], p[1], p[2]));
|
|
mesh.normals.push(normal);
|
|
}
|
|
mesh.triangles.extend([[offset, offset + 1, offset + 2], [offset, offset + 2, offset + 3]]);
|
|
mesh.tri_face.extend([0, 0]);
|
|
}
|
|
let bounds = mesh.bounds();
|
|
ProductScene {
|
|
bounds,
|
|
meshes: vec![ProductMesh {
|
|
name: "original slab".into(),
|
|
mesh: Arc::new(mesh),
|
|
color: [255; 3],
|
|
opacity: 1.0,
|
|
surface: Some(OpaqueSurface::new(Vec3::ZERO, 0.0, 0.1, 1.5).unwrap()),
|
|
transmission: Some(
|
|
solidcraft_render::transmission::Transmission::new(Vec3::new(-0.5_f64.ln(), -0.8_f64.ln(), 0.0), thin.then_some(1.0)).unwrap(),
|
|
),
|
|
faces: vec![],
|
|
}],
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_solid_and_thin_slabs_match_absorbing_interreflection_oracle() {
|
|
let Some(executor) = executor() else { return };
|
|
for (thin, thickness) in [(false, 1.0), (true, 1.0), (true, 0.0)] {
|
|
let mut scene = glass_slab(thin);
|
|
if thin {
|
|
let sigma = scene.meshes[0].transmission.unwrap().extinction();
|
|
scene.meshes[0].transmission = Some(solidcraft_render::transmission::Transmission::new(sigma, Some(thickness)).unwrap());
|
|
}
|
|
let (_, expected) = solidcraft_render::transmission::slab(scene.meshes[0].transmission.unwrap(), thickness, 1.0, 1.0, 1.5).unwrap();
|
|
let mut request = request(1);
|
|
request.camera.fov = 0.0001;
|
|
let options = JobOptions { samples: 4096, max_depth: 16, seed: 1948, ..Default::default() };
|
|
let mut task = Task::new(executor.context.clone(), scene, request, options, CancelToken::default()).unwrap();
|
|
task.environment = 1.0;
|
|
task.environment_bottom_only = true;
|
|
// Deliberately large offset: Beer uses unshifted geometric endpoints.
|
|
task.epsilon = 0.05;
|
|
task.studio = 0.0;
|
|
for _ in 0..options.samples {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
let actual = task.read_linear().unwrap()[0];
|
|
for (a, b) in actual.iter().zip([expected.x, expected.y, expected.z]) {
|
|
assert!((f64::from(*a) - b).abs() < 0.015, "slab thin={thin} thickness={thickness}: {actual:?} vs {expected:?}");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn shader_validates_without_a_device() {
|
|
let module = naga::front::wgsl::parse_str(SHADER).unwrap();
|
|
let parameters = module.types.iter().find(|(_, ty)| ty.name.as_deref() == Some("Params")).unwrap().1;
|
|
let naga::TypeInner::Struct { span, .. } = ¶meters.inner else { panic!("Params must be a struct") };
|
|
assert_eq!(*span as usize, PARAMETER_BYTES);
|
|
naga::valid::Validator::new(naga::valid::ValidationFlags::all(), naga::valid::Capabilities::empty()).validate(&module).unwrap();
|
|
}
|
|
|
|
/// #6705: native compilers inline every call. With 33 inlined BVH walks in `main` (three path
|
|
/// samples, a shadow walk per light source family) NVIDIA's Vulkan compiler crashed or ran out
|
|
/// of memory and never built the pipeline. Count the walks `main` inlines, so another call site
|
|
/// is a deliberate choice, checked on such a driver.
|
|
#[test]
|
|
fn main_inlines_few_bvh_walks() {
|
|
fn callees(block: &naga::Block, out: &mut Vec<naga::Handle<naga::Function>>) {
|
|
for statement in block.iter() {
|
|
match statement {
|
|
naga::Statement::Call { function, .. } => out.push(*function),
|
|
naga::Statement::Block(inner) => callees(inner, out),
|
|
naga::Statement::If { accept, reject, .. } => {
|
|
callees(accept, out);
|
|
callees(reject, out);
|
|
}
|
|
naga::Statement::Switch { cases, .. } => cases.iter().for_each(|case| callees(&case.body, out)),
|
|
naga::Statement::Loop { body, continuing, .. } => {
|
|
callees(body, out);
|
|
callees(continuing, out);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
fn walks(module: &naga::Module, function: &naga::Function) -> usize {
|
|
let mut called = Vec::new();
|
|
callees(&function.body, &mut called);
|
|
called
|
|
.into_iter()
|
|
.map(|handle| {
|
|
let callee = &module.functions[handle];
|
|
let walk = matches!(callee.name.as_deref(), Some("trace_precise_within" | "trace_ordered_within"));
|
|
usize::from(walk) + walks(module, callee)
|
|
})
|
|
.sum()
|
|
}
|
|
let module = naga::front::wgsl::parse_str(SHADER).unwrap();
|
|
let main = module.entry_points.iter().find(|entry| entry.name == "main").unwrap();
|
|
let inlined = walks(&module, &main.function);
|
|
assert!(inlined <= 5, "`main` inlines {inlined} BVH walks");
|
|
}
|
|
|
|
#[test]
|
|
fn render_lights_path_visibility_uniform_keeps_the_shader_contract() {
|
|
shader_validates_without_a_device();
|
|
let request = request(4);
|
|
assert!(request.studio_weights.is_none());
|
|
}
|
|
|
|
/// #3217: the path tracer opens Vulkan adapters, or Metal on macOS, never D3D12 or GL.
|
|
#[test]
|
|
fn path_devices_are_vulkan_or_metal_only() {
|
|
let picked = crate::select::pick_path(crate::select::Policy::Auto, |_| true);
|
|
if let Some((adapter, _)) = &picked {
|
|
assert!(matches!(adapter.get_info().backend, wgpu::Backend::Vulkan | wgpu::Backend::Metal));
|
|
}
|
|
if crate::select::path_backends().is_empty() {
|
|
assert!(picked.is_none());
|
|
}
|
|
}
|
|
|
|
/// #6706: executors opened side by side never compile the path pipeline at the same time.
|
|
#[test]
|
|
fn path_pipelines_compile_one_at_a_time() {
|
|
use std::sync::atomic::AtomicUsize;
|
|
let inside = AtomicUsize::new(0);
|
|
let most = AtomicUsize::new(0);
|
|
std::thread::scope(|scope| {
|
|
for _ in 0..8 {
|
|
scope.spawn(|| {
|
|
let _compiling = one_compile_at_a_time();
|
|
most.fetch_max(inside.fetch_add(1, Ordering::SeqCst) + 1, Ordering::SeqCst);
|
|
std::thread::sleep(Duration::from_millis(5));
|
|
inside.fetch_sub(1, Ordering::SeqCst);
|
|
});
|
|
}
|
|
});
|
|
assert_eq!(most.load(Ordering::SeqCst), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn viewport_path_backends_keep_windows_on_its_selected_backend() {
|
|
for backend in [wgpu::Backend::Dx12, wgpu::Backend::Gl, wgpu::Backend::Vulkan] {
|
|
let allowed = viewport_path_backends(backend, true);
|
|
assert_eq!(allowed, wgpu::Backends::from(backend));
|
|
assert_eq!(allowed.contains(wgpu::Backends::VULKAN), backend == wgpu::Backend::Vulkan);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn viewport_path_backends_preserve_other_platforms() {
|
|
for backend in [wgpu::Backend::Vulkan, wgpu::Backend::Gl, wgpu::Backend::Metal] {
|
|
assert_eq!(viewport_path_backends(backend, false), crate::select::path_backends());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn admission_rejects_hostile_parameters_and_transparency() {
|
|
let mut scene = sphere(white());
|
|
let mut r = request(16);
|
|
for size in [0, (GPU_PATH_LIMITS.max_dimension + 1) as u32, u32::MAX] {
|
|
r.width = size;
|
|
assert!(admission(&scene, &r, JobOptions::default()).is_err());
|
|
}
|
|
r.width = 16;
|
|
for samples in [0, 4097, u32::MAX] {
|
|
assert!(admission(&scene, &r, JobOptions { samples, ..Default::default() }).is_err());
|
|
}
|
|
for depth in [0, 17, u32::MAX] {
|
|
assert!(admission(&scene, &r, JobOptions { max_depth: depth, ..Default::default() }).is_err());
|
|
}
|
|
for ev in [f64::NAN, f64::INFINITY, 33.0] {
|
|
assert!(admission(&scene, &r, JobOptions { exposure_ev: ev, ..Default::default() }).is_err());
|
|
}
|
|
scene.meshes[0].opacity = 0.5;
|
|
assert!(admission(&scene, &r, JobOptions::default()).is_err());
|
|
scene.meshes[0].opacity = 1.0;
|
|
Arc::make_mut(&mut scene.meshes[0].mesh).triangles[0][0] = u32::MAX;
|
|
assert!(scene::flatten(&scene, Vec3::ZERO, &CancelToken::default()).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn admission_ignores_the_cpu_raster_projected_pixel_limit() {
|
|
let mesh = 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)],
|
|
normals: vec![Vec3::Z; 3],
|
|
triangles: vec![[0, 1, 2]; 3201],
|
|
tri_face: vec![0; 3201],
|
|
..Default::default()
|
|
};
|
|
let scene = ProductScene {
|
|
bounds: mesh.bounds(),
|
|
meshes: vec![ProductMesh {
|
|
name: "overlapping triangles".into(),
|
|
mesh: Arc::new(mesh),
|
|
color: [255; 3],
|
|
opacity: 1.0,
|
|
surface: Some(white()),
|
|
transmission: None,
|
|
faces: Vec::new(),
|
|
}],
|
|
};
|
|
let mut r = request(100);
|
|
r.camera.distance = 1.0;
|
|
r.camera.fov = 0.0;
|
|
let raster_error = solidcraft_render::job::admit(&scene, &r).unwrap_err();
|
|
assert_eq!(raster_error.code, ErrorCode::LimitExceeded);
|
|
assert!(raster_error.message.contains("128000000 pixel tests"), "{raster_error:?}");
|
|
// Exercise the actual GPU admission path without requiring a Vulkan device.
|
|
let gpu = admission(&scene, &r, JobOptions::default()).unwrap();
|
|
assert_eq!(gpu.projected_pixel_tests, None);
|
|
assert!(gpu.estimated_total_bytes > gpu.geometry_bytes);
|
|
}
|
|
|
|
#[test]
|
|
fn admission_applies_the_gpu_estimate_instead_of_the_cpu_raster_budget() {
|
|
// A library-bounded source (not an ordinary UI scene): about 100 MiB of face appearances
|
|
// on a small mesh at the largest image. Its CPU raster estimate is above 384 MiB (covered
|
|
// in the render crate); the GPU's own estimate stays within its 512 MiB job cap.
|
|
let count = (100 * 1024 * 1024 / std::mem::size_of::<solidcraft_render::FaceAppearance>()).min(1_000_000);
|
|
let mut scene = sphere(white());
|
|
let appearance = solidcraft_render::FaceAppearance { face: 0, color: [255; 3], opacity: 1.0, surface: None, transmission: None };
|
|
scene.meshes[0].faces = vec![appearance; count];
|
|
let r = request(2048);
|
|
let a = admission(&scene, &r, JobOptions::default()).unwrap();
|
|
assert!(a.estimated_total_bytes <= 512 * 1024 * 1024, "{a:?}");
|
|
assert_eq!(a.face_appearances, count as u64);
|
|
// The CPU host still rejects the same source.
|
|
assert_eq!(solidcraft_render::job::admit(&scene, &r).unwrap_err().code, ErrorCode::LimitExceeded);
|
|
}
|
|
|
|
#[test]
|
|
fn bvh_handles_empty_and_cancelled_scenes() {
|
|
let empty = ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY };
|
|
let upload = scene::flatten(&empty, Vec3::ZERO, &CancelToken::default()).unwrap();
|
|
assert_eq!(upload.nodes.len(), 32);
|
|
assert_eq!(&upload.nodes[12..16], &u32::MAX.to_le_bytes());
|
|
let cancel = CancelToken::default();
|
|
cancel.cancel();
|
|
assert_eq!(scene::flatten(&sphere(white()), Vec3::ZERO, &cancel).err().unwrap().code, ErrorCode::Cancelled);
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_brdf_matches_f64_surface_oracle() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context
|
|
.device
|
|
.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("path BRDF reference"), source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
for metallic in [0.0, 0.5, 1.0] {
|
|
for roughness in [0.045, 0.25, 1.0] {
|
|
for ior in [1.0, 1.5, 3.0] {
|
|
let surface = OpaqueSurface::new(Vec3::new(0.8, 0.5, 0.2), metallic, roughness, ior).unwrap();
|
|
let mut task = Task::new(context.clone(), sphere(surface), request(1), JobOptions::default(), CancelToken::default()).unwrap();
|
|
for (view, light) in [
|
|
(Vec3::Z, Vec3::Z),
|
|
(Vec3::new(0.5, 0.2, 1.0), Vec3::new(-0.4, 0.3, 0.8)),
|
|
(Vec3::new(1.0, 0.0, 0.02), Vec3::new(-1.0, 0.1, 0.02)),
|
|
] {
|
|
let view = view.normalized().unwrap();
|
|
let light = light.normalized().unwrap();
|
|
let mut params = vec![0; 48];
|
|
scene::vector(&mut params, light, 0.0);
|
|
scene::vector(&mut params, Vec3::Z, 0.0);
|
|
scene::vector(&mut params, view, 0.0);
|
|
scene::vector(&mut params, Vec3::ZERO, 0.0);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let actual = task.read_linear().unwrap()[0];
|
|
let expected = surface.brdf(Vec3::Z, view, light).unwrap();
|
|
if metallic == 0.0 && ior == 1.0 {
|
|
let diffuse = Vec3::new(0.8, 0.5, 0.2) / std::f64::consts::PI;
|
|
assert!((expected - diffuse).len() < 1e-12, "index-matched diffuse has no interface reflection");
|
|
}
|
|
for (a, b) in actual.iter().zip([expected.x, expected.y, expected.z]) {
|
|
assert!((f64::from(*a) - b).abs() <= 3e-3 * b.abs() + 2e-5, "m={metallic}, r={roughness}, ior={ior}: {a} vs {b}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Assemble the same viewport declarations, lighting helpers and PBR implementation
|
|
/// as production, plus a compute entry point that calls the actual BRDF.
|
|
fn viewport_brdf_probe_source() -> String {
|
|
format!(
|
|
"{}\n{}\n{}",
|
|
crate::view::SHADER,
|
|
crate::pbr::SOURCE,
|
|
r#"
|
|
struct Probe { base: vec4<f32>, parameters: vec4<f32>, view: vec4<f32>, light: vec4<f32>, };
|
|
// Bindings 0 and 1 belong to the production viewport uniform and palette.
|
|
@group(0) @binding(2) var<uniform> probe: Probe;
|
|
@group(0) @binding(3) var<storage, read_write> result: array<vec4<f32>>;
|
|
@compute @workgroup_size(1)
|
|
fn probe_pbr() {
|
|
result[0] = vec4<f32>(pbr_brdf(probe.base.xyz, probe.parameters.xyz,
|
|
vec3<f32>(0.0,0.0,1.0),probe.view.xyz,probe.light.xyz),1.0);
|
|
}
|
|
"#
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn viewport_brdf_probe_shader_is_valid() {
|
|
let source = viewport_brdf_probe_source();
|
|
let module = naga::front::wgsl::parse_str(&source).unwrap_or_else(|error| panic!("{}", error.emit_to_string(&source)));
|
|
naga::valid::Validator::new(naga::valid::ValidationFlags::all(), naga::valid::Capabilities::empty())
|
|
.validate(&module)
|
|
.unwrap_or_else(|error| panic!("{}", error.emit_to_string(&source)));
|
|
}
|
|
|
|
/// The viewport embeds a separate WGSL translation. Exercise its actual function
|
|
/// on the same native device as the path-tracer oracle, not a copied Rust formula.
|
|
#[test]
|
|
fn viewport_brdf_matches_f64_surface_oracle_at_index_match() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let source = viewport_brdf_probe_source();
|
|
let creation_scopes = scopes(&context.device);
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
|
label: Some("actual viewport PBR oracle"),
|
|
source: wgpu::ShaderSource::Wgsl(source.into()),
|
|
});
|
|
let layout = context.device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
|
label: None,
|
|
entries: &[
|
|
wgpu::BindGroupLayoutEntry {
|
|
binding: 2,
|
|
visibility: wgpu::ShaderStages::COMPUTE,
|
|
ty: wgpu::BindingType::Buffer { ty: wgpu::BufferBindingType::Uniform, has_dynamic_offset: false, min_binding_size: None },
|
|
count: None,
|
|
},
|
|
wgpu::BindGroupLayoutEntry {
|
|
binding: 3,
|
|
visibility: wgpu::ShaderStages::COMPUTE,
|
|
ty: wgpu::BindingType::Buffer {
|
|
ty: wgpu::BufferBindingType::Storage { read_only: false },
|
|
has_dynamic_offset: false,
|
|
min_binding_size: None,
|
|
},
|
|
count: None,
|
|
},
|
|
],
|
|
});
|
|
let pipeline_layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&pipeline_layout),
|
|
module: &shader,
|
|
entry_point: Some("probe_pbr"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
let uniform = context.device.create_buffer(&wgpu::BufferDescriptor {
|
|
label: None,
|
|
size: 64,
|
|
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
|
|
mapped_at_creation: false,
|
|
});
|
|
let values = context.device.create_buffer(&wgpu::BufferDescriptor {
|
|
label: None,
|
|
size: 16,
|
|
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
|
|
mapped_at_creation: false,
|
|
});
|
|
let readback = context.device.create_buffer(&wgpu::BufferDescriptor {
|
|
label: None,
|
|
size: 16,
|
|
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
|
|
mapped_at_creation: false,
|
|
});
|
|
let bind = context.device.create_bind_group(&wgpu::BindGroupDescriptor {
|
|
label: None,
|
|
layout: &layout,
|
|
entries: &[
|
|
wgpu::BindGroupEntry { binding: 2, resource: uniform.as_entire_binding() },
|
|
wgpu::BindGroupEntry { binding: 3, resource: values.as_entire_binding() },
|
|
],
|
|
});
|
|
checked(creation_scopes).expect("viewport BRDF probe resource creation must validate");
|
|
for metallic in [0.0, 0.5, 1.0] {
|
|
for roughness in [0.045, 0.5, 1.0] {
|
|
for ior in [1.0, 1.5, 3.0] {
|
|
let base = Vec3::new(0.8, 0.5, 0.2);
|
|
let surface = OpaqueSurface::new(base, metallic, roughness, ior).unwrap();
|
|
for (view, light) in [
|
|
(Vec3::Z, Vec3::Z),
|
|
(Vec3::new(0.5, 0.0, 1.0).normalized().unwrap(), Vec3::new(-0.4, 0.3, 0.8).normalized().unwrap()),
|
|
(Vec3::new(1.0, 0.0, 0.02).normalized().unwrap(), Vec3::new(-1.0, 0.1, 0.02).normalized().unwrap()),
|
|
] {
|
|
let input = [
|
|
0.8_f32,
|
|
0.5,
|
|
0.2,
|
|
0.0,
|
|
metallic as f32,
|
|
roughness as f32,
|
|
ior as f32,
|
|
0.0,
|
|
view.x as f32,
|
|
view.y as f32,
|
|
view.z as f32,
|
|
0.0,
|
|
light.x as f32,
|
|
light.y as f32,
|
|
light.z as f32,
|
|
0.0,
|
|
];
|
|
let bytes: Vec<u8> = input.iter().flat_map(|value| value.to_le_bytes()).collect();
|
|
let dispatch_scopes = scopes(&context.device);
|
|
context.queue.write_buffer(&uniform, 0, &bytes);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
encoder.copy_buffer_to_buffer(&values, 0, &readback, 0, 16);
|
|
let submission = context.queue.submit([encoder.finish()]);
|
|
checked(dispatch_scopes).expect("viewport BRDF probe dispatch must validate");
|
|
let slice = readback.slice(..);
|
|
let (tx, rx) = std::sync::mpsc::channel();
|
|
slice.map_async(wgpu::MapMode::Read, move |result| {
|
|
let _ = tx.send(result);
|
|
});
|
|
context.wait(submission, TIMEOUT).unwrap();
|
|
rx.try_recv().unwrap().unwrap();
|
|
let data = slice.get_mapped_range().unwrap();
|
|
let actual: Vec<f32> = data.as_chunks::<4>().0.iter().map(|bytes| f32::from_le_bytes(*bytes)).collect();
|
|
drop(data);
|
|
readback.unmap();
|
|
let expected = surface.brdf(Vec3::Z, view, light).unwrap();
|
|
if metallic == 0.0 && ior == 1.0 {
|
|
assert!((expected - base / std::f64::consts::PI).len() < 1e-12);
|
|
}
|
|
for (a, b) in actual.iter().zip([expected.x, expected.y, expected.z]) {
|
|
assert!((f64::from(*a) - b).abs() < 2e-5 + 3e-3 * b.abs(), "viewport m={metallic}, r={roughness}, ior={ior}: {a} vs {b}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_tiny_scene_matches_cpu_studio_with_face_appearance() {
|
|
let Some(executor) = executor() else { return };
|
|
let surface = OpaqueSurface::new(Vec3::new(0.7, 0.2, 0.1), 0.5, 0.3, 1.5).unwrap();
|
|
let mesh = Mesh {
|
|
positions: vec![Vec3::new(-3.0, -3.0, 0.0), Vec3::new(3.0, -3.0, 0.0), Vec3::new(3.0, 3.0, 0.0), Vec3::new(-3.0, 3.0, 0.0)],
|
|
normals: vec![Vec3::Z; 4],
|
|
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
|
tri_face: vec![7, 9],
|
|
..Default::default()
|
|
};
|
|
let bounds = mesh.bounds();
|
|
let scene = ProductScene {
|
|
meshes: vec![ProductMesh {
|
|
name: "reference plane".into(),
|
|
mesh: Arc::new(mesh),
|
|
color: [255; 3],
|
|
opacity: 1.0,
|
|
surface: Some(white()),
|
|
transmission: None,
|
|
faces: [7, 9]
|
|
.map(|face| solidcraft_render::FaceAppearance { face, color: [0; 3], opacity: 1.0, surface: Some(surface), transmission: None })
|
|
.to_vec(),
|
|
}],
|
|
bounds,
|
|
};
|
|
let mut task =
|
|
Task::new(executor.context.clone(), scene, request(4), JobOptions { samples: 4, max_depth: 1, ..Default::default() }, CancelToken::default())
|
|
.unwrap();
|
|
for _ in 0..4 {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
let actual = task.read_linear().unwrap();
|
|
let expected = solidcraft_render::studio::shade(surface, Vec3::Z, Vec3::Z).unwrap();
|
|
for pixel in actual {
|
|
assert_eq!(pixel[3], 1.0);
|
|
for (a, b) in pixel.iter().zip([expected.x, expected.y, expected.z]) {
|
|
assert!((f64::from(*a) - b).abs() < 3e-3 * b.abs() + 2e-5, "{a} vs {b}");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_furnace_fixed_seed_and_cancellation() {
|
|
let Some(executor) = executor() else { return };
|
|
let options = JobOptions { samples: 4096, max_depth: 8, seed: 37, ..Default::default() };
|
|
let mut task = Task::new(executor.context.clone(), sphere(white()), request(8), options, CancelToken::default()).unwrap();
|
|
task.environment = 1.0;
|
|
task.studio = 0.0;
|
|
for _ in 0..options.samples {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
let result = task.read_linear().unwrap();
|
|
eprintln!("furnace centre {:?}; BVH {:.3} ms; upload {} bytes / {:.3} ms", result[27], task.metrics.0, task.metrics.1, task.metrics.2);
|
|
// The oracle includes Schlick entry/exit attenuation even at IOR=1, plus single-
|
|
// scattering GGX. It is near-white, not an exactly energy-preserving Lambert model.
|
|
for index in [27, 28, 35, 36] {
|
|
assert!((result[index][0] - 1.0).abs() < 0.07, "furnace radiance: {:?}", result[index]);
|
|
}
|
|
let mut repeat = Task::new(executor.context.clone(), sphere(white()), request(8), options, CancelToken::default()).unwrap();
|
|
repeat.environment = 1.0;
|
|
repeat.studio = 0.0;
|
|
for _ in 0..options.samples {
|
|
repeat.complete_sample().unwrap();
|
|
}
|
|
assert_eq!(result, repeat.read_linear().unwrap(), "fixed sample indices and seed must repeat on the same adapter");
|
|
let token = CancelToken::default();
|
|
let mut cancelled = Task::new(executor.context.clone(), sphere(white()), request(16), options, token.clone()).unwrap();
|
|
cancelled.dispatch().unwrap();
|
|
token.cancel();
|
|
assert_eq!(cancelled.step(4096).err().unwrap().code, ErrorCode::Cancelled);
|
|
}
|
|
|
|
#[test]
|
|
fn skinny_polar_triangles_do_not_shadow_themselves() {
|
|
let Some(executor) = executor() else { return };
|
|
let mut image = request(32);
|
|
image.camera.distance = 16.0;
|
|
image.camera.fov = 0.0005;
|
|
let mut task = Task::new(
|
|
executor.context.clone(),
|
|
sphere_section(white(), 512, 1024, 1),
|
|
image,
|
|
JobOptions { samples: 1, max_depth: 1, ..Default::default() },
|
|
CancelToken::default(),
|
|
)
|
|
.unwrap();
|
|
task.complete_sample().unwrap();
|
|
let pixels = task.read_linear().unwrap();
|
|
for (index, pixel) in pixels.iter().enumerate() {
|
|
assert_eq!(pixel[3], 1.0, "polar cap covers the image: {index} {pixel:?}");
|
|
assert!(pixel[0] > 0.1, "outward-facing cap must receive unobstructed studio light: {index} {pixel:?}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn native_host_cancel_never_publishes_a_frame() {
|
|
let Some(executor) = executor() else { return };
|
|
let host = ImageHost::with_executor(Arc::new(executor)).unwrap();
|
|
let job = host
|
|
.submit_with_options(
|
|
solidcraft_render::job::JobId { session: 1, serial: 1, generation: 1 },
|
|
1,
|
|
sphere(white()),
|
|
request(64),
|
|
JobOptions { samples: 4096, ..Default::default() },
|
|
)
|
|
.unwrap();
|
|
let deadline = Instant::now() + Duration::from_secs(30);
|
|
loop {
|
|
let status = job.status().unwrap();
|
|
if status.progress.phase == Phase::Running {
|
|
break;
|
|
}
|
|
assert!(!status.progress.phase.terminal(), "{status:?}");
|
|
assert!(Instant::now() < deadline);
|
|
std::thread::sleep(Duration::from_millis(5));
|
|
}
|
|
job.cancel().unwrap();
|
|
assert_eq!(job.wait_timeout(Duration::from_secs(30)).unwrap().progress.phase, Phase::Cancelled);
|
|
assert!(job.frame().unwrap().is_none());
|
|
}
|
|
|
|
/// Explicit benchmark: large allocation and sustained GPU load must not run in ordinary CI.
|
|
#[test]
|
|
#[ignore = "manual 1M-triangle 1920x1080 GPU performance measurement"]
|
|
fn path_performance() {
|
|
let executor = executor().expect("benchmark requires an adapter");
|
|
let samples = std::env::var("SOLIDCRAFT_PATH_BENCH_SAMPLES").ok().map(|s| s.parse::<u32>().unwrap()).unwrap_or(1);
|
|
let options = JobOptions { samples, ..Default::default() };
|
|
options.validate().unwrap();
|
|
let surface = OpaqueSurface::new(Vec3::new(0.8, 0.4, 0.2), 0.25, 0.4, 1.5).unwrap();
|
|
let scene = sphere_grid(surface, 512, 1024);
|
|
let mut request = request(1920);
|
|
request.height = 1080;
|
|
let admitted = executor.admit(&scene, &request, options).unwrap();
|
|
let mut task = Task::new(executor.context.clone(), scene, request, options, CancelToken::default()).unwrap();
|
|
let started = Instant::now();
|
|
while task.sample < samples {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
let seconds = started.elapsed().as_secs_f64();
|
|
let linear = task.read_linear().unwrap();
|
|
assert!(linear.iter().all(|p| p.iter().all(|v| v.is_finite())));
|
|
let coverage = linear.iter().map(|p| f64::from(p[3])).sum::<f64>() / linear.len() as f64;
|
|
assert!((0.16..0.19).contains(&coverage), "sphere must occupy the expected projected area: {coverage}");
|
|
let centre = linear[540 * 1920 + 960];
|
|
let lit = linear.iter().filter(|p| p[0] > 0.01).count();
|
|
eprintln!(
|
|
"PATH_BENCH_DIAGNOSTIC coverage={coverage:.6} centre={centre:?} lit_pixels={lit} nearby={:?}",
|
|
[linear[500 * 1920 + 960], linear[540 * 1920 + 1000], linear[580 * 1920 + 960]]
|
|
);
|
|
assert_eq!(centre[3], 1.0);
|
|
assert!(centre[0] > 0.01, "benchmark must actually shade the sphere: {centre:?}");
|
|
eprintln!("PATH_BENCH_IMAGE coverage={coverage:.6} centre={centre:?}");
|
|
eprintln!(
|
|
"PATH_BENCH input_triangles={} resolution=1920x1080 spp={} bvh_ms={:.3} upload_bytes={} upload_ms={:.3} admitted_bytes={} render_seconds={:.6} ms_per_spp={:.3}",
|
|
admitted.triangles,
|
|
samples,
|
|
task.metrics.0,
|
|
task.metrics.1,
|
|
task.metrics.2,
|
|
admitted.estimated_total_bytes,
|
|
seconds,
|
|
seconds * 1000.0 / f64::from(samples)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn admission_refuses_cpu_options_without_opening_a_device() {
|
|
let scene = ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY };
|
|
let mut input = request(16);
|
|
input.integrator = solidcraft_render::job::Integrator::Raytrace;
|
|
assert_eq!(admission(&scene, &input, JobOptions::default()).unwrap_err().code, ErrorCode::InvalidRequest);
|
|
input.integrator = solidcraft_render::job::Integrator::Raster;
|
|
input.raytrace = Some(solidcraft_render::job::RaytraceOptions::default());
|
|
assert_eq!(admission(&scene, &input, JobOptions::default()).unwrap_err().code, ErrorCode::InvalidRequest);
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_clear_coat_brdf_matches_f64_surface_oracle() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context
|
|
.device
|
|
.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("path BRDF reference"), source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
for metallic in [0.0, 1.0] {
|
|
for roughness in [0.045, 0.12, 0.5] {
|
|
for ior in [1.5, 3.0] {
|
|
let surface = OpaqueSurface::new(Vec3::new(0.8, 0.5, 0.2), metallic, 0.3, 1.5)
|
|
.unwrap()
|
|
.with_clear_coat(solidcraft_render::clear_coat::ClearCoat::new(1.0, roughness, ior).unwrap());
|
|
let mut task = Task::new(context.clone(), sphere(surface), request(1), JobOptions::default(), CancelToken::default()).unwrap();
|
|
for (view, light) in [
|
|
(Vec3::Z, Vec3::Z),
|
|
(Vec3::new(0.5, 0.2, 1.0), Vec3::new(-0.4, 0.3, 0.8)),
|
|
(Vec3::new(1.0, 0.0, 0.02), Vec3::new(-1.0, 0.1, 0.02)),
|
|
] {
|
|
let view = view.normalized().unwrap();
|
|
let light = light.normalized().unwrap();
|
|
let mut params = vec![0; 48];
|
|
scene::vector(&mut params, light, 0.0);
|
|
scene::vector(&mut params, Vec3::Z, 0.0);
|
|
scene::vector(&mut params, view, 0.0);
|
|
scene::vector(&mut params, Vec3::ZERO, 0.0);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let actual = task.read_linear().unwrap()[0];
|
|
let expected = surface.brdf(Vec3::Z, view, light).unwrap();
|
|
for (a, b) in actual.iter().zip([expected.x, expected.y, expected.z]) {
|
|
assert!((f64::from(*a) - b).abs() <= 3e-3 * b.abs() + 2e-5, "m={metallic}, r={roughness}, ior={ior}: {a} vs {b}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_clear_coat_pdf_matches_f64_surface_oracle() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context
|
|
.device
|
|
.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("path BRDF reference"), source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("pdf_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
for metallic in [0.0, 1.0] {
|
|
for roughness in [0.045, 0.12, 0.5] {
|
|
for ior in [1.5, 3.0] {
|
|
let surface = OpaqueSurface::new(Vec3::new(0.8, 0.5, 0.2), metallic, 0.3, 1.5)
|
|
.unwrap()
|
|
.with_clear_coat(solidcraft_render::clear_coat::ClearCoat::new(1.0, roughness, ior).unwrap());
|
|
let mut task = Task::new(context.clone(), sphere(surface), request(1), JobOptions::default(), CancelToken::default()).unwrap();
|
|
for (view, light) in [
|
|
(Vec3::Z, Vec3::Z),
|
|
(Vec3::new(0.5, 0.2, 1.0), Vec3::new(-0.4, 0.3, 0.8)),
|
|
(Vec3::new(1.0, 0.0, 0.02), Vec3::new(-1.0, 0.1, 0.02)),
|
|
] {
|
|
let view = view.normalized().unwrap();
|
|
let light = light.normalized().unwrap();
|
|
let mut params = vec![0; 48];
|
|
scene::vector(&mut params, light, 0.0);
|
|
scene::vector(&mut params, Vec3::Z, 0.0);
|
|
scene::vector(&mut params, view, 0.0);
|
|
scene::vector(&mut params, Vec3::ZERO, 0.0);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let actual = task.read_linear().unwrap()[0];
|
|
let expected = solidcraft_render::clear_coat::surface_pdf(surface, Vec3::Z, view, light).unwrap();
|
|
for (a, b) in actual.iter().zip([expected, 0.0, 0.0]) {
|
|
assert!((f64::from(*a) - b).abs() <= 3e-3 * b.abs() + 2e-5, "m={metallic}, r={roughness}, ior={ior}: {a} vs {b}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_clear_coat_samples_the_pdf_mixture_components() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context
|
|
.device
|
|
.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("coat sampling oracle"), source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("surface_sample_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
for weight in [0.0, 0.4, 1.0] {
|
|
let surface = OpaqueSurface::new(Vec3::new(0.02, 0.02, 0.02), 0.0, 0.45, 1.5)
|
|
.unwrap()
|
|
.with_clear_coat(solidcraft_render::clear_coat::ClearCoat::new(weight, 0.12, 1.5).unwrap());
|
|
let mut task = Task::new(context.clone(), sphere(surface), request(1), JobOptions::default(), CancelToken::default()).unwrap();
|
|
let p = weight * 0.5;
|
|
// One variate strictly inside each nonempty mixture interval.
|
|
for component in [(1.0 - p) * 0.25, (1.0 - p) * 0.75, 1.0 - p * 0.5] {
|
|
if component >= 1.0 {
|
|
continue;
|
|
}
|
|
for x in [0.125_f64, 0.75] {
|
|
let mut params = vec![0; 48];
|
|
scene::vector(&mut params, Vec3::ZERO, 0.0);
|
|
scene::vector(&mut params, Vec3::Z, 0.0);
|
|
scene::vector(&mut params, Vec3::Z, 0.0);
|
|
scene::vector(&mut params, Vec3::new(component, x, 0.25), 0.0);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let actual = task.read_linear().unwrap()[0];
|
|
let expected = if component < (1.0 - p) * 0.5 {
|
|
Vec3::new(0.0, x.sqrt(), (1.0 - x).sqrt())
|
|
} else {
|
|
let r = if component >= 1.0 - p { 0.12_f64 } else { 0.45_f64 };
|
|
let c = ((1.0 - x) / (1.0 + (r.powi(4) - 1.0) * x)).sqrt();
|
|
Vec3::new(0.0, 2.0 * c * (1.0 - c * c).sqrt(), 2.0 * c * c - 1.0)
|
|
} + Vec3::new(2.0, 2.0, 2.0);
|
|
for (a, b) in actual.iter().zip([expected.x, expected.y, expected.z]) {
|
|
assert!((f64::from(*a) - b).abs() < 2e-5, "weight={weight}, component={component}, x={x}: {actual:?}, {expected:?}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_studio_area_mis_matches_independent_quadrature_and_distance_visibility() {
|
|
use solidcraft_render::job::{AreaLight, AreaLights, StudioLighting};
|
|
let Some(executor) = executor() else { return };
|
|
let surface = white();
|
|
let plane = |z: f64| {
|
|
let mesh = Mesh {
|
|
positions: vec![Vec3::new(-10.0, -10.0, z), Vec3::new(10.0, -10.0, z), Vec3::new(10.0, 10.0, z), Vec3::new(-10.0, 10.0, z)],
|
|
normals: vec![Vec3::Z; 4],
|
|
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
|
tri_face: vec![0, 0],
|
|
..Default::default()
|
|
};
|
|
ProductMesh {
|
|
name: "original quadrature plane".into(),
|
|
mesh: Arc::new(mesh),
|
|
color: [255; 3],
|
|
opacity: 1.0,
|
|
surface: Some(surface),
|
|
transmission: None,
|
|
faces: Vec::new(),
|
|
}
|
|
};
|
|
let light = AreaLight { center: [2.0, 0.0, 2.0], u: [1.0, 0.0, 0.0], v: [0.0, -1.0, 0.0], radiance: [3.0; 3] };
|
|
let mut expected = 0.0;
|
|
for y in 0..256 {
|
|
for x in 0..256 {
|
|
let delta = Vec3::new(1.0 + (f64::from(x) + 0.5) / 128.0, -1.0 + (f64::from(y) + 0.5) / 128.0, 2.0);
|
|
let l = delta.normalized().unwrap();
|
|
expected += surface.brdf(Vec3::Z, Vec3::Z, l).unwrap().x * 3.0 * l.z * l.z / delta.len2() * 4.0 / (256.0 * 256.0);
|
|
}
|
|
}
|
|
for depth in [1, 2] {
|
|
for blocker in [None, Some(4.0), Some(1.0)] {
|
|
let mut scene = ProductScene { meshes: vec![plane(0.0)], bounds: Aabb3::EMPTY };
|
|
if let Some(z) = blocker {
|
|
scene.meshes.push(plane(z));
|
|
}
|
|
// Camera sits below any blocker and sees the receiver. Geometry behind
|
|
// the emitter must not shadow it; the nearer blocker must.
|
|
let mut image = request(1);
|
|
image.camera.distance = 0.1;
|
|
image.camera.fov = 0.001;
|
|
let options = JobOptions {
|
|
samples: 4096,
|
|
max_depth: depth,
|
|
seed: 37,
|
|
lighting: Some(StudioLighting { sun: None, environment: [0.0; 3], area_lights: AreaLights::new(&[light]).unwrap() }),
|
|
..Default::default()
|
|
};
|
|
let mut task = Task::new(executor.context.clone(), scene, image, options, CancelToken::default()).unwrap();
|
|
assert_eq!(task.parameters(1).len(), PARAMETER_BYTES);
|
|
for _ in 0..options.samples {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
let value = f64::from(task.read_linear().unwrap()[0][0]);
|
|
if blocker == Some(1.0) {
|
|
assert!(value < 1e-6, "blocked depth{depth}: {value}");
|
|
} else {
|
|
assert!((value - expected).abs() < 0.04 * expected, "depth{depth}, blocker{blocker:?}: {value} vs {expected}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_studio_environment_mis_matches_furnace_at_last_and_continuing_bounces() {
|
|
use solidcraft_render::job::StudioLighting;
|
|
let Some(executor) = executor() else { return };
|
|
for depth in [1, 2] {
|
|
let options = JobOptions {
|
|
samples: 4096,
|
|
max_depth: depth,
|
|
seed: 37,
|
|
lighting: Some(StudioLighting { sun: None, environment: [1.0; 3], ..Default::default() }),
|
|
..Default::default()
|
|
};
|
|
let mut task = Task::new(executor.context.clone(), sphere(white()), request(8), options, CancelToken::default()).unwrap();
|
|
for _ in 0..options.samples {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
let pixels = task.read_linear().unwrap();
|
|
for index in [27, 28, 35, 36] {
|
|
assert!((pixels[index][0] - 1.0).abs() < 0.07, "depth{depth}: {:?}", pixels[index]);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_emitter_inside_glass_applies_final_segment_absorption() {
|
|
use solidcraft_render::job::{AreaLight, AreaLights, StudioLighting};
|
|
let Some(executor) = executor() else { return };
|
|
let mut glass = sphere(OpaqueSurface::new(Vec3::ZERO, 0.0, 0.1, 1.0).unwrap());
|
|
glass.meshes[0].transmission = Some(solidcraft_render::transmission::Transmission::new(Vec3::new(0.7, 0.3, 0.0), None).unwrap());
|
|
let light = AreaLight { center: [0.0; 3], u: [0.4, 0.0, 0.0], v: [0.0, 0.4, 0.0], radiance: [3.0; 3] };
|
|
let options = JobOptions {
|
|
samples: 16,
|
|
max_depth: 2,
|
|
lighting: Some(StudioLighting { sun: None, environment: [0.0; 3], area_lights: AreaLights::new(&[light]).unwrap() }),
|
|
..Default::default()
|
|
};
|
|
let mut image = request(2);
|
|
image.camera.fov = 0.0001;
|
|
let mut task = Task::new(executor.context.clone(), glass, image, options, CancelToken::default()).unwrap();
|
|
for _ in 0..options.samples {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
for pixel in task.read_linear().unwrap() {
|
|
for (value, sigma) in pixel.iter().zip([0.7_f64, 0.3, 0.0]) {
|
|
assert!((f64::from(*value) - 3.0 * (-sigma).exp()).abs() < 0.002, "{pixel:?}");
|
|
}
|
|
}
|
|
}
|
|
|
|
fn environment_plane() -> ProductScene {
|
|
let mesh = Mesh {
|
|
positions: vec![Vec3::new(-3.0, -3.0, 0.0), Vec3::new(3.0, -3.0, 0.0), Vec3::new(3.0, 3.0, 0.0), Vec3::new(-3.0, 3.0, 0.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();
|
|
ProductScene {
|
|
meshes: vec![ProductMesh {
|
|
name: "original environment test plane".into(),
|
|
mesh: Arc::new(mesh),
|
|
color: [255; 3],
|
|
opacity: 1.0,
|
|
surface: Some(white()),
|
|
transmission: None,
|
|
faces: Vec::new(),
|
|
}],
|
|
bounds,
|
|
}
|
|
}
|
|
fn original_hdr() -> Vec<u8> {
|
|
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, 128, 128, 129]);
|
|
}
|
|
bytes
|
|
}
|
|
#[test]
|
|
fn gpu_hdr_environment_matches_constant_furnace_and_resource_admission() {
|
|
use solidcraft_render::lighting::environment::EnvironmentSource;
|
|
let Some(executor) = executor() else { return };
|
|
let source = Arc::new(EnvironmentSource::hdr(original_hdr(), 0.3, 1.0, false).unwrap());
|
|
let mut image = request(8);
|
|
image.environment = Some(source.clone());
|
|
let options = JobOptions { samples: 2048, max_depth: 2, seed: 37, ..Default::default() };
|
|
let plain = admission(&sphere(white()), &request(8), options).unwrap();
|
|
let with_map = admission(&sphere(white()), &image, options).unwrap();
|
|
assert_eq!(with_map.estimated_total_bytes - plain.estimated_total_bytes, source.admitted_bytes());
|
|
let mut task = Task::new(executor.context.clone(), sphere(white()), image, options, CancelToken::default()).unwrap();
|
|
for _ in 0..options.samples {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
let pixels = task.read_linear().unwrap();
|
|
for index in [27, 28, 35, 36] {
|
|
assert!((pixels[index][0] - 1.0).abs() < 0.07, "{:?}", pixels[index]);
|
|
}
|
|
}
|
|
#[test]
|
|
fn gpu_finite_sun_matches_cone_quadrature_at_final_and_continuing_bounces() {
|
|
use solidcraft_render::job::{StudioLighting, Sun};
|
|
let Some(executor) = executor() else { return };
|
|
let sun = Sun { direction: [0.0, 0.0, 1.0], angular_radius_rad: 0.4, radiance: [3.0; 3] };
|
|
let mut expected = 0.0;
|
|
for i in 0..4096 {
|
|
let z = 1.0 - (f64::from(i) + 0.5) / 4096.0 * (1.0 - sun.angular_radius_rad.cos());
|
|
let l = Vec3::new((1.0 - z * z).sqrt(), 0.0, z);
|
|
expected += white().brdf(Vec3::Z, Vec3::Z, l).unwrap().x * z * 3.0 * sun.solid_angle() / 4096.0;
|
|
}
|
|
for max_depth in [1, 2] {
|
|
let mut image = request(2);
|
|
image.camera.distance = 0.1;
|
|
image.camera.fov = 0.001;
|
|
let options = JobOptions {
|
|
samples: 2048,
|
|
max_depth,
|
|
seed: 123,
|
|
lighting: Some(StudioLighting { sun: Some(sun), ..Default::default() }),
|
|
..Default::default()
|
|
};
|
|
let mut task = Task::new(executor.context.clone(), environment_plane(), image, options, CancelToken::default()).unwrap();
|
|
for _ in 0..options.samples {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
for pixel in task.read_linear().unwrap() {
|
|
assert!((f64::from(pixel[0]) - expected).abs() < 0.03 * expected, "depth{max_depth}: {pixel:?}, {expected}");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_environment_orientation_rotation_intensity_and_pdf_match_cpu() {
|
|
use solidcraft_render::lighting::environment::EnvironmentSource;
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let mut bytes = b"#?RADIANCE\nFORMAT=32-bit_rle_rgbe\n\n-Y 2 +X 4\n".to_vec();
|
|
for i in 0..8u8 {
|
|
bytes.extend_from_slice(&[16 * (i + 1), 32, 64, 129]);
|
|
}
|
|
let rotation = 0.7_f64;
|
|
let intensity = 2.5;
|
|
let source = Arc::new(EnvironmentSource::hdr(bytes, rotation, intensity, true).unwrap());
|
|
let cpu = source.prepare(&CancelToken::default()).unwrap();
|
|
let mut image = request(1);
|
|
image.environment = Some(source);
|
|
let mut task = Task::new(context.clone(), sphere(white()), image, JobOptions::default(), CancelToken::default()).unwrap();
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor { label: None, source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("environment_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
for row in 0..2 {
|
|
for column in 0..4 {
|
|
let theta = std::f64::consts::PI * (f64::from(row) + 0.5) / 2.0;
|
|
let phi = std::f64::consts::TAU * (f64::from(column) + 0.5) / 4.0;
|
|
let local = Vec3::new(theta.sin() * phi.cos(), theta.sin() * phi.sin(), theta.cos());
|
|
let direction =
|
|
Vec3::new(rotation.cos() * local.x - rotation.sin() * local.y, rotation.sin() * local.x + rotation.cos() * local.y, local.z);
|
|
let mut params = task.parameters(1);
|
|
for (out, value) in params[48..60].as_chunks_mut::<4>().0.iter_mut().zip([direction.x, direction.y, direction.z]) {
|
|
out.copy_from_slice(&(value as f32).to_le_bytes());
|
|
}
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let actual = task.read_linear().unwrap()[0];
|
|
let (rgb, pdf) = cpu.evaluate(local).unwrap();
|
|
for (a, b) in actual.iter().zip(rgb.into_iter().map(|v| v * intensity as f32).chain([pdf])) {
|
|
assert!((a - b).abs() < 1e-5, "{actual:?} vs {rgb:?}/{pdf}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn shadow_probe(context: &Arc<Context>, scene: ProductScene, origin: Vec3, direction: Vec3, limit: f64) -> [[f32; 4]; 2] {
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
|
label: Some("shadow connection oracle"),
|
|
source: wgpu::ShaderSource::Wgsl(SHADER.into()),
|
|
});
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("shadow_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
let mut task = Task::new(context.clone(), scene, request(2), JobOptions::default(), CancelToken::default()).unwrap();
|
|
let mut params = vec![0; 32];
|
|
scene::vector(&mut params, origin, 0.0);
|
|
scene::vector(&mut params, Vec3::ZERO, 0.0);
|
|
scene::vector(&mut params, Vec3::ZERO, 0.0);
|
|
scene::vector(&mut params, direction, limit as f32);
|
|
// Large offset catches Beer intervals incorrectly measured from shifted origins.
|
|
scene::vector(&mut params, Vec3::new(0.01, 0.0, 0.0), 0.0);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let pixels = task.read_linear().unwrap();
|
|
[pixels[0], pixels[1]]
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_shadow_sheets_solids_endpoints_and_invalid_crossings_match_oracles() {
|
|
use solidcraft_render::transmission::{slab, solid_shadow};
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
for thin in [true, false] {
|
|
let mut scene = glass_slab(thin);
|
|
let optics = scene.meshes[0].transmission.unwrap().with_shadow_transmission(true);
|
|
scene.meshes[0].transmission = Some(optics);
|
|
for cosine in [1.0_f64, 0.8] {
|
|
let d = Vec3::new((1.0 - cosine * cosine).sqrt(), 0.0, -cosine);
|
|
let actual = shadow_probe(context, scene.clone(), Vec3::new(0.0, 0.0, 2.0), d, 8.0);
|
|
let expected =
|
|
if thin { slab(optics, 1.0, cosine, 1.0, 1.5).unwrap().1 } else { solid_shadow(optics, 1.0 / cosine, cosine, cosine, 1.5).unwrap() };
|
|
for (a, b) in actual[0].iter().zip([expected.x, expected.y, expected.z]) {
|
|
assert!((f64::from(*a) - b).abs() < 2e-5, "thin={thin}, cosine={cosine}: {actual:?} vs {expected:?}");
|
|
}
|
|
assert_eq!(actual[1][1], if thin { 1.0 } else { 2.0 });
|
|
}
|
|
let before = shadow_probe(context, scene.clone(), Vec3::new(0.0, 0.0, 2.0), -Vec3::Z, 1.0);
|
|
assert_eq!(before[0], [1.0; 4]);
|
|
if !thin {
|
|
let inside = shadow_probe(context, scene.clone(), Vec3::new(0.0, 0.0, 2.0), -Vec3::Z, 2.0);
|
|
let expected = optics.attenuation(0.5).unwrap() * (0.96 / 2.25);
|
|
for (a, b) in inside[0].iter().zip([expected.x, expected.y, expected.z]) {
|
|
assert!((f64::from(*a) - b).abs() < 2e-5);
|
|
}
|
|
// Shadow rays start at shading points, which may touch or lie inside
|
|
// glass. A first exit infers that medium and absorbs from the origin.
|
|
let from_inside = shadow_probe(context, scene.clone(), Vec3::ZERO, Vec3::Z, 8.0);
|
|
let expected = optics.attenuation(0.5).unwrap() * 0.96;
|
|
for (a, b) in from_inside[0].iter().zip([expected.x, expected.y, expected.z]) {
|
|
assert!((f64::from(*a) - b).abs() < 2e-5, "{from_inside:?} vs {expected:?}");
|
|
}
|
|
assert_eq!(from_inside[1][1], 1.0);
|
|
}
|
|
scene.meshes[0].transmission = Some(optics.with_shadow_transmission(false));
|
|
assert_eq!(shadow_probe(context, scene, Vec3::new(0.0, 0.0, 2.0), -Vec3::Z, 8.0)[0], [0.0, 0.0, 0.0, 1.0]);
|
|
}
|
|
let mut opaque = glass_slab(true);
|
|
opaque.meshes[0].transmission = None;
|
|
assert_eq!(shadow_probe(context, opaque, Vec3::new(0.0, 0.0, 2.0), -Vec3::Z, 8.0)[0], [0.0, 0.0, 0.0, 1.0]);
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_shadow_interface_walk_is_bounded_and_stacked_sheet_pdf_matches() {
|
|
let Some(executor) = executor() else { return };
|
|
for count in [2_u32, 64, 65] {
|
|
let mut scene = glass_slab(true);
|
|
let base = scene.meshes[0].mesh.clone();
|
|
let mut mesh = Mesh::default();
|
|
for layer in 0..count {
|
|
let offset = mesh.positions.len() as u32;
|
|
mesh.positions.extend(base.positions.iter().map(|p| *p - Vec3::Z * f64::from(layer)));
|
|
mesh.normals.extend_from_slice(&base.normals);
|
|
mesh.triangles.extend(base.triangles.iter().map(|t| t.map(|i| i + offset)));
|
|
mesh.tri_face.extend_from_slice(&base.tri_face);
|
|
}
|
|
scene.meshes[0].mesh = Arc::new(mesh);
|
|
scene.meshes[0].transmission = Some(solidcraft_render::transmission::Transmission::new(Vec3::ZERO, Some(0.0)).unwrap());
|
|
let actual = shadow_probe(&executor.context, scene, Vec3::new(0.0, 0.0, 2.0), -Vec3::Z, 100.0);
|
|
if count == 65 {
|
|
assert_eq!(actual[0], [0.0, 0.0, 0.0, 1.0]);
|
|
} else {
|
|
let expected = (0.96_f64 / 1.04).powi(count as i32);
|
|
assert!((f64::from(actual[0][0]) - expected).abs() < 2e-5);
|
|
assert!((f64::from(actual[1][0]) - expected).abs() < 2e-5);
|
|
assert_eq!(actual[1][1], count as f32);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_shadow_mis_does_not_double_direct_energy_through_index_matched_glass() {
|
|
use solidcraft_render::job::{AreaLight, AreaLights, StudioLighting};
|
|
let Some(executor) = executor() else { return };
|
|
let surface = white();
|
|
let receiver = ProductMesh {
|
|
name: "shadow MIS receiver".into(),
|
|
mesh: Arc::new(Mesh {
|
|
positions: vec![Vec3::new(-20.0, -20.0, -2.0), Vec3::new(20.0, -20.0, -2.0), Vec3::new(20.0, 20.0, -2.0), Vec3::new(-20.0, 20.0, -2.0)],
|
|
normals: vec![Vec3::Z; 4],
|
|
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
|
tri_face: vec![0, 0],
|
|
..Default::default()
|
|
}),
|
|
color: [255; 3],
|
|
opacity: 1.0,
|
|
surface: Some(surface),
|
|
transmission: None,
|
|
faces: vec![],
|
|
};
|
|
let light = AreaLight { center: [0.0, 0.0, 2.0], u: [4.0, 0.0, 0.0], v: [0.0, -4.0, 0.0], radiance: [1.0; 3] };
|
|
let mut expected = 0.0;
|
|
for y in 0..128 {
|
|
for x in 0..128 {
|
|
let delta = Vec3::new(-4.0 + (f64::from(x) + 0.5) / 16.0, -4.0 + (f64::from(y) + 0.5) / 16.0, 4.0);
|
|
let l = delta.normalized().unwrap();
|
|
expected += surface.brdf(Vec3::Z, Vec3::Z, l).unwrap().x * l.z * l.z / delta.len2() * 64.0 / 16384.0;
|
|
}
|
|
}
|
|
for (thin, enabled, depth) in [(true, true, 2), (true, true, 4), (true, false, 4), (false, true, 1), (false, true, 4), (false, false, 4)] {
|
|
let mut scene = glass_slab(thin);
|
|
scene.meshes[0].surface = Some(OpaqueSurface::new(Vec3::ZERO, 0.0, 0.1, 1.0).unwrap());
|
|
scene.meshes[0].transmission =
|
|
Some(solidcraft_render::transmission::Transmission::new(Vec3::ZERO, thin.then_some(0.0)).unwrap().with_shadow_transmission(enabled));
|
|
scene.meshes.push(receiver.clone());
|
|
let options = JobOptions {
|
|
samples: 4096,
|
|
max_depth: depth,
|
|
seed: 37,
|
|
lighting: Some(StudioLighting { sun: None, environment: [0.0; 3], area_lights: AreaLights::new(&[light]).unwrap() }),
|
|
..Default::default()
|
|
};
|
|
let mut image = request(1);
|
|
image.camera.target = Vec3::new(0.0, 0.0, -2.0);
|
|
image.camera.distance = 0.1;
|
|
image.camera.fov = 0.001;
|
|
let mut task = Task::new(executor.context.clone(), scene, image, options, CancelToken::default()).unwrap();
|
|
for _ in 0..options.samples {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
let actual = f64::from(task.read_linear().unwrap()[0][0]);
|
|
assert!((actual - expected).abs() < 0.08 * expected, "thin={thin}, enabled={enabled}, depth={depth}: {actual} vs {expected}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_absorbing_two_sheet_mis_matches_f64_quadrature() {
|
|
use solidcraft_render::job::{AreaLight, AreaLights, StudioLighting};
|
|
let Some(executor) = executor() else { return };
|
|
let surface = white();
|
|
// A tiny receiver excludes sheet-reflection returns from this direct-only oracle.
|
|
// Its half-width still exceeds the primary ray footprint by two orders of magnitude.
|
|
let receiver = ProductMesh {
|
|
name: "shadow MIS receiver".into(),
|
|
mesh: Arc::new(Mesh {
|
|
positions: vec![Vec3::new(-0.01, -0.01, -2.0), Vec3::new(0.01, -0.01, -2.0), Vec3::new(0.01, 0.01, -2.0), Vec3::new(-0.01, 0.01, -2.0)],
|
|
normals: vec![Vec3::Z; 4],
|
|
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
|
tri_face: vec![0, 0],
|
|
..Default::default()
|
|
}),
|
|
color: [255; 3],
|
|
opacity: 1.0,
|
|
surface: Some(surface),
|
|
transmission: None,
|
|
faces: vec![],
|
|
};
|
|
let light = AreaLight { center: [0.0, 0.0, 2.0], u: [4.0, 0.0, 0.0], v: [0.0, -4.0, 0.0], radiance: [1.0; 3] };
|
|
let optics = solidcraft_render::transmission::Transmission::new(Vec3::new(0.2, 0.1, 0.05), Some(0.7)).unwrap();
|
|
let mut expected = 0.0;
|
|
for y in 0..128 {
|
|
for x in 0..128 {
|
|
let delta = Vec3::new(-4.0 + (f64::from(x) + 0.5) / 16.0, -4.0 + (f64::from(y) + 0.5) / 16.0, 4.0);
|
|
let l = delta.normalized().unwrap();
|
|
let transmission = solidcraft_render::transmission::slab(optics, 0.7, l.z, 1.0, 1.5).unwrap().1.x;
|
|
expected += transmission * transmission * surface.brdf(Vec3::Z, Vec3::Z, l).unwrap().x * l.z * l.z / delta.len2() * 64.0 / 16384.0;
|
|
}
|
|
}
|
|
for (thin, enabled, depth) in [(true, true, 1), (true, true, 4), (true, false, 4)] {
|
|
let mut scene = glass_slab(thin);
|
|
scene.meshes[0].transmission = Some(optics.with_shadow_transmission(enabled));
|
|
let mut second = scene.meshes[0].clone();
|
|
second.name = "second absorbing sheet".into();
|
|
for p in &mut Arc::make_mut(&mut second.mesh).positions {
|
|
p.z -= 1.0;
|
|
}
|
|
scene.meshes.push(second);
|
|
scene.meshes.push(receiver.clone());
|
|
let options = JobOptions {
|
|
samples: 4096,
|
|
max_depth: depth,
|
|
seed: 37,
|
|
lighting: Some(StudioLighting { sun: None, environment: [0.0; 3], area_lights: AreaLights::new(&[light]).unwrap() }),
|
|
..Default::default()
|
|
};
|
|
let mut image = request(1);
|
|
image.camera.target = Vec3::new(0.0, 0.0, -2.0);
|
|
image.camera.distance = 0.1;
|
|
image.camera.fov = 0.001;
|
|
let mut task = Task::new(executor.context.clone(), scene, image, options, CancelToken::default()).unwrap();
|
|
for _ in 0..options.samples {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
let actual = f64::from(task.read_linear().unwrap()[0][0]);
|
|
assert!((actual - expected).abs() < 0.08 * expected, "thin={thin}, enabled={enabled}, depth={depth}: {actual} vs {expected}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_hdr_and_sun_shadow_mis_preserve_index_matched_energy() {
|
|
use solidcraft_render::job::{StudioLighting, Sun};
|
|
use solidcraft_render::lighting::environment::EnvironmentSource;
|
|
let Some(executor) = executor() else { return };
|
|
let sun = Sun { direction: [0.0, 0.0, 1.0], angular_radius_rad: 0.4, radiance: [3.0; 3] };
|
|
let mut sun_expected = 0.0;
|
|
for i in 0..4096 {
|
|
let z = 1.0 - (f64::from(i) + 0.5) / 4096.0 * (1.0 - sun.angular_radius_rad.cos());
|
|
let l = Vec3::new((1.0 - z * z).sqrt(), 0.0, z);
|
|
sun_expected += white().brdf(Vec3::Z, Vec3::Z, l).unwrap().x * z * 3.0 * sun.solid_angle() / 4096.0;
|
|
}
|
|
// The original HDR has unit radiance everywhere. With IOR one the receiver
|
|
// is pure diffuse; retain the independent directional-albedo quadrature.
|
|
let mut hdr_expected = 0.0;
|
|
for i in 0..256 {
|
|
let z = (f64::from(i) + 0.5) / 256.0;
|
|
for j in 0..256 {
|
|
let phi = (f64::from(j) + 0.5) / 256.0 * std::f64::consts::TAU;
|
|
let l = Vec3::new((1.0 - z * z).sqrt() * phi.cos(), (1.0 - z * z).sqrt() * phi.sin(), z);
|
|
hdr_expected += white().brdf(Vec3::Z, Vec3::Z, l).unwrap().x * z * std::f64::consts::TAU / 65536.0;
|
|
}
|
|
}
|
|
for solar in [false, true] {
|
|
for (thin, depth) in [(true, 2), (true, 4), (false, 1), (false, 4)] {
|
|
let mut scene = glass_slab(thin);
|
|
scene.meshes[0].surface = Some(OpaqueSurface::new(Vec3::ZERO, 0.0, 0.1, 1.0).unwrap());
|
|
scene.meshes[0].transmission =
|
|
Some(solidcraft_render::transmission::Transmission::new(Vec3::ZERO, thin.then_some(0.0)).unwrap().with_shadow_transmission(true));
|
|
let mut receiver = environment_plane().meshes.remove(0);
|
|
for p in &mut Arc::make_mut(&mut receiver.mesh).positions {
|
|
p.z -= 2.0;
|
|
}
|
|
scene.meshes.push(receiver);
|
|
scene.bounds = scene.meshes.iter().fold(Aabb3::EMPTY, |a, m| a.union(&m.mesh.bounds()));
|
|
let mut image = request(1);
|
|
image.camera.target = Vec3::new(0.0, 0.0, -2.0);
|
|
image.camera.distance = 0.1;
|
|
image.camera.fov = 0.001;
|
|
if !solar {
|
|
image.environment = Some(Arc::new(EnvironmentSource::hdr(original_hdr(), 0.3, 1.0, false).unwrap()));
|
|
}
|
|
let options = JobOptions {
|
|
samples: 4096,
|
|
max_depth: depth,
|
|
seed: 37,
|
|
lighting: Some(StudioLighting { sun: solar.then_some(sun), ..Default::default() }),
|
|
..Default::default()
|
|
};
|
|
let mut task = Task::new(executor.context.clone(), scene, image, options, CancelToken::default()).unwrap();
|
|
for _ in 0..options.samples {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
let actual = f64::from(task.read_linear().unwrap()[0][0]);
|
|
let expected = if solar { sun_expected } else { hdr_expected };
|
|
assert!((actual - expected).abs() < 0.07 * expected, "sun={solar}, thin={thin}, depth={depth}: {actual} vs {expected}");
|
|
}
|
|
}
|
|
}
|
|
|
|
fn texture_fixture(frame: solidcraft_render::job::textures::PlanarFrame) -> Arc<solidcraft_render::job::textures::RuntimeTextures> {
|
|
use image::ImageEncoder;
|
|
use solidcraft_render::{
|
|
job::textures::{RuntimeTextures, TextureBinding, TextureMap},
|
|
texture_input::MapRole,
|
|
};
|
|
let map = |pixels: &[u8], role| {
|
|
let mut bytes = Vec::new();
|
|
image::codecs::png::PngEncoder::new(&mut bytes).write_image(pixels, 2, 2, image::ExtendedColorType::Rgba8).unwrap();
|
|
TextureMap::new(bytes, role).unwrap()
|
|
};
|
|
Arc::new(
|
|
RuntimeTextures::new(vec![TextureBinding {
|
|
body_index: 0,
|
|
body_name: "original sphere".into(),
|
|
frame,
|
|
normal_strength: 0.75,
|
|
base_color: Some(map(&[128, 64, 255, 0, 255, 0, 32, 255, 64, 128, 192, 0, 0, 255, 128, 255], MapRole::BaseColor)),
|
|
normal: Some(map(&[128, 128, 255, 0, 192, 128, 224, 255, 128, 192, 224, 0, 64, 96, 224, 255], MapRole::NormalOpenGl)),
|
|
roughness: None,
|
|
metallic: None,
|
|
base_color_mode: Default::default(),
|
|
flip_v: false,
|
|
}])
|
|
.unwrap(),
|
|
)
|
|
}
|
|
#[test]
|
|
fn texture_admission_rejects_glass_and_stale_identity_and_honors_cancellation() {
|
|
use solidcraft_render::job::textures::PlanarFrame;
|
|
let source = texture_fixture(PlanarFrame { origin: [0.; 3], u: [1., 0., 0.], v: [0., 1., 0.] });
|
|
let mut input = request(2);
|
|
input.textures = Some(source.clone());
|
|
let mut scene = sphere(white());
|
|
let plain = admission(&scene, &request(2), JobOptions::default()).unwrap();
|
|
let textured = admission(&scene, &input, JobOptions::default()).unwrap();
|
|
assert_eq!(textured.preparation_bytes - plain.preparation_bytes, source.working_bytes());
|
|
assert!(solidcraft_render::job::admit(&scene, &input).is_err());
|
|
let cancel = CancelToken::default();
|
|
cancel.cancel();
|
|
assert_eq!(textures::flatten(Some(&source), 1, Vec3::ZERO, &cancel).unwrap_err().code, ErrorCode::Cancelled);
|
|
scene.meshes[0].name = "stale".into();
|
|
assert!(admission(&scene, &input, JobOptions::default()).is_err());
|
|
scene.meshes[0].name = "original sphere".into();
|
|
scene.meshes[0].transmission = Some(clear_glass());
|
|
assert!(admission(&scene, &input, JobOptions::default()).is_err());
|
|
}
|
|
#[test]
|
|
fn gpu_planar_color_and_normal_maps_match_cpu_sampling_oracle() {
|
|
use solidcraft_render::job::textures::{PlanarFrame, sample_map};
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor { label: None, source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("texture_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
for handed in [1., -1.] {
|
|
let frame = PlanarFrame { origin: [0.; 3], u: [2., 0., 0.], v: [0., 2. * handed, 0.] };
|
|
let source = texture_fixture(frame);
|
|
let binding = &source.bindings()[0];
|
|
let base = binding.base_color.as_ref().unwrap().decode(&CancelToken::default()).unwrap();
|
|
let normals = binding.normal.as_ref().unwrap().decode(&CancelToken::default()).unwrap();
|
|
for point in [Vec3::new(0.5, 0.5, 0.), Vec3::new(-0.25, 1.125, 0.), Vec3::new(0., 0., 0.)] {
|
|
let mut input = request(2);
|
|
input.textures = Some(source.clone());
|
|
let mut task = Task::new(context.clone(), sphere(white()), input, JobOptions::default(), CancelToken::default()).unwrap();
|
|
let mut params = vec![0; 32];
|
|
scene::vector(&mut params, point, 0.);
|
|
scene::vector(&mut params, Vec3::ZERO, 0.);
|
|
scene::vector(&mut params, Vec3::Z, 0.);
|
|
scene::vector(&mut params, Vec3::Z, 0.);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let actual = task.read_linear().unwrap();
|
|
let uv = frame.uv(point).unwrap();
|
|
let expected = sample_map(&base, [2, 2], uv).unwrap();
|
|
let mapped = frame.mapped_normal(Vec3::Z, Vec3::Z, sample_map(&normals, [2, 2], uv).unwrap(), 0.75).unwrap();
|
|
for (a, b) in actual[0].iter().zip(expected) {
|
|
assert!((f64::from(*a) - b).abs() < 2e-6, "color {actual:?} vs {expected:?}");
|
|
}
|
|
for (a, b) in actual[1].iter().zip([mapped.x + 2., mapped.y + 2., mapped.z + 2.]) {
|
|
assert!((f64::from(*a) - b).abs() < 3e-6, "normal {actual:?} vs {mapped:?}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_finite_emitter_inside_solid_retains_entry_radiance_eta() {
|
|
use solidcraft_render::job::{AreaLight, AreaLights, StudioLighting};
|
|
let Some(executor) = executor() else { return };
|
|
let surface = white();
|
|
let receiver = ProductMesh {
|
|
name: "shadow MIS receiver".into(),
|
|
mesh: Arc::new(Mesh {
|
|
positions: vec![Vec3::new(-0.01, -0.01, -2.0), Vec3::new(0.01, -0.01, -2.0), Vec3::new(0.01, 0.01, -2.0), Vec3::new(-0.01, 0.01, -2.0)],
|
|
normals: vec![Vec3::Z; 4],
|
|
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
|
tri_face: vec![0, 0],
|
|
..Default::default()
|
|
}),
|
|
color: [255; 3],
|
|
opacity: 1.0,
|
|
surface: Some(surface),
|
|
transmission: None,
|
|
faces: vec![],
|
|
};
|
|
let light = AreaLight { center: [0.0, 0.0, 0.0], u: [9.0, 0.0, 0.0], v: [0.0, -9.0, 0.0], radiance: [1.0; 3] };
|
|
// Broad finite emitter makes edge/refraction disagreement small; the missing eta term is a 125% error.
|
|
let mut expected = 0.0;
|
|
for y in 0..128 {
|
|
for x in 0..128 {
|
|
let delta = Vec3::new(-9.0 + (f64::from(x) + 0.5) * 18.0 / 128.0, -9.0 + (f64::from(y) + 0.5) * 18.0 / 128.0, 2.0);
|
|
let l = delta.normalized().unwrap();
|
|
let r = solidcraft_render::transmission::fresnel(l.z, 1.0, 1.5).unwrap().reflectance();
|
|
expected += (1.0 - r) / 2.25 * surface.brdf(Vec3::Z, Vec3::Z, l).unwrap().x * l.z * l.z / delta.len2() * 324.0 / 16384.0;
|
|
}
|
|
}
|
|
for (thin, enabled, depth) in [(false, true, 1), (false, true, 4), (false, false, 4)] {
|
|
let mut scene = glass_slab(thin);
|
|
scene.meshes[0].surface = Some(OpaqueSurface::new(Vec3::ZERO, 0.0, 0.1, 1.5).unwrap());
|
|
scene.meshes[0].transmission =
|
|
Some(solidcraft_render::transmission::Transmission::new(Vec3::ZERO, thin.then_some(0.0)).unwrap().with_shadow_transmission(enabled));
|
|
scene.meshes.push(receiver.clone());
|
|
let options = JobOptions {
|
|
samples: 4096,
|
|
max_depth: depth,
|
|
seed: 37,
|
|
lighting: Some(StudioLighting { sun: None, environment: [0.0; 3], area_lights: AreaLights::new(&[light]).unwrap() }),
|
|
..Default::default()
|
|
};
|
|
let mut image = request(1);
|
|
image.camera.target = Vec3::new(0.0, 0.0, -2.0);
|
|
image.camera.distance = 0.1;
|
|
image.camera.fov = 0.001;
|
|
let mut task = Task::new(executor.context.clone(), scene, image, options, CancelToken::default()).unwrap();
|
|
for _ in 0..options.samples {
|
|
task.complete_sample().unwrap();
|
|
}
|
|
let actual = f64::from(task.read_linear().unwrap()[0][0]);
|
|
assert!((actual - expected).abs() < 0.08 * expected, "thin={thin}, enabled={enabled}, depth={depth}: {actual} vs {expected}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn path_device_limits_require_six_storage_buffers_without_changing_raster_defaults() {
|
|
let mut supported = wgpu::Limits::downlevel_defaults();
|
|
assert_eq!(supported.max_storage_buffers_per_shader_stage, 4);
|
|
assert!(device_limits(supported.clone()).is_err());
|
|
supported.max_storage_buffers_per_shader_stage = 8;
|
|
let requested = device_limits(supported.clone()).unwrap();
|
|
let mut expected = wgpu::Limits::downlevel_defaults().using_resolution(supported);
|
|
expected.max_storage_buffers_per_shader_stage = 6;
|
|
assert_eq!(requested, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_secondary_closed_corner_exits_are_not_skipped() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
|
label: Some("closed corner boundary oracle"),
|
|
source: wgpu::ShaderSource::Wgsl(SHADER.into()),
|
|
});
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("boundary_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
for case in 0..3 {
|
|
let pyramid = case == 1;
|
|
let mut scene = glass_slab(false);
|
|
let (origin, direction) = if pyramid {
|
|
let mut mesh = Mesh::default();
|
|
let corners = [Vec3::new(-1., -1., 1.), Vec3::new(1., -1., 1.), Vec3::new(1., 1., 1.), Vec3::new(-1., 1., 1.)];
|
|
let tip = Vec3::new(0., 0., -1.);
|
|
let faces = [
|
|
[corners[0], corners[1], corners[2]],
|
|
[corners[0], corners[2], corners[3]],
|
|
[corners[1], corners[0], tip],
|
|
[corners[2], corners[1], tip],
|
|
[corners[3], corners[2], tip],
|
|
[corners[0], corners[3], tip],
|
|
];
|
|
for face in faces {
|
|
let n = (face[1] - face[0]).cross(face[2] - face[0]).normalized().unwrap();
|
|
let first = mesh.positions.len() as u32;
|
|
mesh.positions.extend(face);
|
|
mesh.normals.extend([n; 3]);
|
|
mesh.triangles.push([first, first + 1, first + 2]);
|
|
mesh.tri_face.push(0);
|
|
}
|
|
scene.meshes[0].mesh = Arc::new(mesh);
|
|
scene.bounds = scene.meshes[0].mesh.bounds();
|
|
(Vec3::new(0.9999, 0., 2.), -Vec3::Z)
|
|
} else {
|
|
(Vec3::new(9.9999, if case == 2 { 9.9999 } else { 0. }, 2.), Vec3::new(1., 0., -1.).normalized().unwrap())
|
|
};
|
|
let mut task = Task::new(context.clone(), scene, request(2), JobOptions::default(), CancelToken::default()).unwrap();
|
|
let mut params = vec![0; 32];
|
|
scene::vector(&mut params, origin, 0.);
|
|
scene::vector(&mut params, direction, 0.);
|
|
scene::vector(&mut params, Vec3::ZERO, 0.);
|
|
scene::vector(&mut params, -Vec3::Z, 0.);
|
|
scene::vector(&mut params, Vec3::new(0.001, 0., 0.), 0.);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let values = task.read_linear().unwrap();
|
|
let result = values[0];
|
|
let expected_distance = if pyramid { 0.0002 } else { 0.0001 * 2.0_f32.sqrt() };
|
|
assert!((values[1][0] - expected_distance).abs() < 3e-6, "case={case}: {:?}", values);
|
|
assert_eq!(result, if pyramid { [0., 0., 1., 1.] } else { [0., 1., 1., 1.] }, "pyramid={pyramid}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_triangle_bound_away_rejects_rounded_behind_origin_hit() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
|
label: Some("positive triangle oracle"),
|
|
source: wgpu::ShaderSource::Wgsl(SHADER.into()),
|
|
});
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("positive_triangle_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
// Actual stored f32 tank-edge failure. Ray starts at the minimum x and moves
|
|
// away, yet the projected distance numerator previously rounded positive.
|
|
let vertices = [[218.38487_f32, -3.8715396, -86.], [220.27007, -2.9226143, 85.], [218.38487, -3.8715396, 85.]];
|
|
let origin = [218.38487_f32, -3.871542, -67.5458];
|
|
let direction = [-0.3121568_f32, -0.45083842, 0.8362433];
|
|
for axis in 0..3 {
|
|
for sign in [-1.0, 1.0] {
|
|
let transform =
|
|
|v: [f32; 3]| Vec3::new(f64::from(v[axis]) * sign, f64::from(v[(axis + 1) % 3]) * sign, f64::from(v[(axis + 2) % 3]) * sign);
|
|
let points = vertices.map(transform);
|
|
let d = transform(direction);
|
|
let n = (points[1] - points[0]).cross(points[2] - points[0]).normalized().unwrap();
|
|
let mesh = Mesh { positions: points.to_vec(), normals: vec![n; 3], triangles: vec![[0, 1, 2]], tri_face: vec![0], ..Default::default() };
|
|
let mut scene = sphere_grid(white(), 2, 3);
|
|
scene.bounds = mesh.bounds();
|
|
scene.meshes[0].mesh = Arc::new(mesh);
|
|
for positive in [false, true] {
|
|
// Close positive intersections remain admitted; no epsilon is used.
|
|
let o = if positive { (points[0] + points[1] + points[2]) / 3.0 - d * 0.001 } else { transform(origin) };
|
|
let mut task = Task::new(context.clone(), scene.clone(), request(1), JobOptions::default(), CancelToken::default()).unwrap();
|
|
let mut params = vec![0; 32];
|
|
scene::vector(&mut params, o, 0.);
|
|
scene::vector(&mut params, d, 0.);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let values = task.read_linear().unwrap();
|
|
assert_eq!(values[0][0], if positive { 1.0 } else { 0.0 }, "axis={axis} sign={sign} positive={positive}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_oblique_coplanar_grazing_reflection_does_not_rehit() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
|
label: Some("coplanar boundary oracle"),
|
|
source: wgpu::ShaderSource::Wgsl(SHADER.into()),
|
|
});
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("coplanar_boundary_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
let a = Vec3::new(f64::from(191.3_f32), f64::from(79.2_f32), f64::from(84.7_f32));
|
|
let points = [a, a + Vec3::new(8., 0., 2.), a + Vec3::new(8., 8., 6.), a + Vec3::new(0., 8., 4.)];
|
|
let n = Vec3::new(-0.25, -0.5, 1.).normalized().unwrap();
|
|
let d = Vec3::new(f64::from(-0.69632584_f32), f64::from(0.69628024_f32), f64::from(0.17413844_f32));
|
|
assert!(n.dot(d) > 0.0, "outward reflection");
|
|
let mesh =
|
|
Mesh { positions: points.to_vec(), normals: vec![n; 4], triangles: vec![[0, 1, 2], [0, 2, 3]], tri_face: vec![0, 0], ..Default::default() };
|
|
let mut scene = sphere_grid(white(), 2, 3);
|
|
scene.bounds = mesh.bounds();
|
|
scene.meshes[0].mesh = Arc::new(mesh);
|
|
let mut task = Task::new(context.clone(), scene, request(2), JobOptions::default(), CancelToken::default()).unwrap();
|
|
let mut params = vec![0; 32];
|
|
scene::vector(&mut params, Vec3::new(f64::from(1.734274e-6_f32), f64::from(0.23548841_f32), 0.), 0.);
|
|
scene::vector(&mut params, d, 0.);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let values = task.read_linear().unwrap();
|
|
// A source point on this exact stored plane and an outward ray cannot hit
|
|
// its adjacent coplanar triangle at any strictly positive distance.
|
|
assert_eq!(values[0][0], 0.0, "hit/distance={:?}, reconstructed={:?}", values[0], values[1]);
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_shadow_closed_corner_keeps_short_exit_segment() {
|
|
let Some(executor) = executor() else { return };
|
|
let mut scene = glass_slab(false);
|
|
let optics = scene.meshes[0].transmission.unwrap().with_shadow_transmission(true);
|
|
scene.meshes[0].transmission = Some(optics);
|
|
let cosine = std::f64::consts::FRAC_1_SQRT_2;
|
|
let actual = shadow_probe(&executor.context, scene, Vec3::new(8.4999, 0., 2.), Vec3::new(cosine, 0., -cosine), 4.);
|
|
let expected = solidcraft_render::transmission::solid_shadow(optics, 0.0001 * 2.0_f64.sqrt(), cosine, cosine, 1.5).unwrap();
|
|
assert_eq!(actual[1][1], 2.0, "{actual:?}");
|
|
for (a, b) in actual[0].iter().zip([expected.x, expected.y, expected.z]) {
|
|
assert!((f64::from(*a) - b).abs() < 2e-5, "{actual:?} vs {expected:?}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_shadow_endpoint_near_interfaces_uses_true_distance() {
|
|
let Some(executor) = executor() else { return };
|
|
let mut scene = glass_slab(false);
|
|
let optics = scene.meshes[0].transmission.unwrap().with_shadow_transmission(true);
|
|
scene.meshes[0].transmission = Some(optics);
|
|
// shadow_probe deliberately uses epsilon .01. Both offsets are smaller
|
|
// than its old 2epsilon cutoff, and must still classify the actual endpoint.
|
|
for (limit, length, factor, crossings) in
|
|
[(1.495, 0.0, 1.0, 0.0), (1.505, 0.005, 0.96 / 2.25, 1.0), (2.495, 0.995, 0.96 / 2.25, 1.0), (2.505, 1.0, 0.96 * 0.96, 2.0)]
|
|
{
|
|
let actual = shadow_probe(&executor.context, scene.clone(), Vec3::new(0., 0., 2.), -Vec3::Z, limit);
|
|
let expected = optics.attenuation(length).unwrap() * factor;
|
|
assert_eq!(actual[1][1], crossings, "limit={limit}: {actual:?}");
|
|
for (a, b) in actual[0].iter().zip([expected.x, expected.y, expected.z]) {
|
|
assert!((f64::from(*a) - b).abs() < 2e-5, "limit={limit}: {actual:?} vs {expected:?}");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_long_ray_thin_corner_orders_entry_before_exit() {
|
|
let Some(executor) = executor() else { return };
|
|
let origin = Vec3::new(f64::from(f32::from_bits(0x43ad5626)), f64::from(f32::from_bits(0x44737912)), f64::from(f32::from_bits(0xc2dd2710)));
|
|
let direction = Vec3::new(f64::from(f32::from_bits(0xbe341340)), f64::from(f32::from_bits(0xbf762fdb)), f64::from(f32::from_bits(0x3e577470)));
|
|
// Captured stored-f32 tank side entry and top exit. Independent f64 plane
|
|
// distances are 929.5224413721813 and 929.5225421330013 respectively.
|
|
let side = [Vec3::new(243., 80., -86.), Vec3::new(157., 80., 85.), Vec3::new(243., 80., 85.)];
|
|
let top = [Vec3::new(157., 80., 85.), Vec3::new(160., 77., 85.), Vec3::new(243., 80., 85.)];
|
|
assert_entry_before_exit(&executor.context, origin, direction, side, top);
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_camera_ray_sharp_rim_tie_orders_entry_before_exit() {
|
|
let Some(executor) = executor() else { return };
|
|
let origin = Vec3::new(f64::from(f32::from_bits(0xc409ad54)), f64::from(f32::from_bits(0xc45c5451)), f64::from(f32::from_bits(0x44160000)));
|
|
let direction = Vec3::new(f64::from(f32::from_bits(0x3eac85fe)), f64::from(f32::from_bits(0x3f3d52db)), f64::from(f32::from_bits(0xbf152b54)));
|
|
// Captured 64-spp coffee camera ray across the bin rim. Exact ray
|
|
// parameters are 1124.0922606444 (entry) and 1124.0923198562 (exit):
|
|
// closer than one f32 ULP, and both rounded to one scaled distance.
|
|
let bottom = [Vec3::new(-152., -50., -55.), Vec3::new(-212., -50., -55.), Vec3::new(-182., -53., -55.)];
|
|
let side = [Vec3::new(-152., -50., -55.), Vec3::new(-152., -50., -124.), Vec3::new(-212., -50., -55.)];
|
|
assert_entry_before_exit(&executor.context, origin, direction, bottom, side);
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_exact_rim_tie_prefers_entry_from_outside() {
|
|
let Some(executor) = executor() else { return };
|
|
// The ray crosses the shared rim edge itself: both faces report the same
|
|
// exact depth, so only the medium-state tie preference can order them.
|
|
let top = [Vec3::new(0., 0., 0.), Vec3::new(0.5, -1., 0.), Vec3::new(1., 0., 0.)];
|
|
let side = [Vec3::new(0., 0., 0.), Vec3::new(1., 0., 0.), Vec3::new(0.5, 0., -1.)];
|
|
assert_entry_before_exit(&executor.context, Vec3::new(0.25, -4., 4.), Vec3::new(0., 1., -1.), top, side);
|
|
}
|
|
|
|
fn assert_entry_before_exit(context: &Arc<Context>, origin: Vec3, direction: Vec3, entry: [Vec3; 3], exit: [Vec3; 3]) {
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
|
label: Some("long-ray ordering oracle"),
|
|
source: wgpu::ShaderSource::Wgsl(SHADER.into()),
|
|
});
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("ordering_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
for permutation in [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]] {
|
|
let odd = (permutation[0] > permutation[1]) ^ (permutation[0] > permutation[2]) ^ (permutation[1] > permutation[2]);
|
|
for reflection in 0..8_u32 {
|
|
let sign = |axis: u32| if reflection & (1 << axis) == 0 { 1.0 } else { -1.0 };
|
|
let transform = |v: Vec3| {
|
|
let a = [v.x, v.y, v.z];
|
|
Vec3::new(a[permutation[0]] * sign(0), a[permutation[1]] * sign(1), a[permutation[2]] * sign(2))
|
|
};
|
|
let invert = odd ^ (reflection.count_ones() % 2 != 0);
|
|
for reverse in [false, true] {
|
|
let mut mesh = Mesh::default();
|
|
for face in if reverse { [exit, entry] } else { [entry, exit] } {
|
|
let mut face = face.map(transform);
|
|
if invert {
|
|
face.swap(1, 2);
|
|
}
|
|
let n = (face[1] - face[0]).cross(face[2] - face[0]).normalized().unwrap();
|
|
let i = mesh.positions.len() as u32;
|
|
mesh.positions.extend(face);
|
|
mesh.normals.extend([n; 3]);
|
|
mesh.triangles.push([i, i + 1, i + 2]);
|
|
mesh.tri_face.push(0);
|
|
}
|
|
let mut scene = sphere_grid(white(), 2, 3);
|
|
scene.bounds = mesh.bounds();
|
|
scene.meshes[0].mesh = Arc::new(mesh);
|
|
let mut task = Task::new(context.clone(), scene, request(2), JobOptions::default(), CancelToken::default()).unwrap();
|
|
let mut params = vec![0; 32];
|
|
scene::vector(&mut params, transform(origin), 0.);
|
|
scene::vector(&mut params, transform(direction), 0.);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let values = task.read_linear().unwrap();
|
|
assert_eq!(
|
|
values[0][0],
|
|
if reverse { 1.0 } else { 0.0 },
|
|
"permutation={permutation:?}, reflection={reflection}, reverse={reverse}, best/candidates={values:?}"
|
|
);
|
|
assert_eq!(values[1][1], 1.0, "candidate0 rejected: {values:?}");
|
|
assert_eq!(values[2][1], 1.0, "candidate1 rejected: {values:?}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[test]
|
|
fn gpu_far_rib_reentry_near_an_edge_is_not_lost_between_paths() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context
|
|
.device
|
|
.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("rib re-entry oracle"), source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("continuation_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
let bits = |x: u32, y: u32, z: u32| Vec3::new(f64::from(f32::from_bits(x)), f64::from(f32::from_bits(y)), f64::from(f32::from_bits(z)));
|
|
// Captured stored-f32 faces of the coffee bin's ribbed wall: the producing
|
|
// face, its nearby neighbour, the far re-entry face sharing the neighbour's
|
|
// edge, and the next exit. The ray leaves the producing face and truly
|
|
// re-enters 2.615 mm later, inside the re-entry face but very close to the
|
|
// shared edge; it then exits 17.529 mm along.
|
|
let faces = [
|
|
[bits(0x438a6e62, 0x4175ca91, 0xc2860000), bits(0x4389b018, 0x416145f8, 0x42c80000), bits(0x438a6e62, 0x4175ca91, 0x42c80000)],
|
|
[bits(0x438b2463, 0x4185b9d0, 0xc2860000), bits(0x438a6e62, 0x4175ca91, 0x42c80000), bits(0x438b2463, 0x4185b9d0, 0x42c80000)],
|
|
[bits(0x438b2463, 0x4185b9d0, 0xc2860000), bits(0x438b2463, 0x4185b9d0, 0x42c80000), bits(0x438bd1ab, 0x419119e4, 0xc2860000)],
|
|
[bits(0x43906f8f, 0x41d4ebca, 0xc28e0000), bits(0x43906f8f, 0x41d4ebca, 0x42c80000), bits(0x438ff618, 0x41c5d6eb, 0xc28e0000)],
|
|
];
|
|
let mut mesh = Mesh::default();
|
|
for face in faces {
|
|
let n = (face[1] - face[0]).cross(face[2] - face[0]).normalized().unwrap();
|
|
let i = mesh.positions.len() as u32;
|
|
mesh.positions.extend(face);
|
|
mesh.normals.extend([n; 3]);
|
|
mesh.triangles.push([i, i + 1, i + 2]);
|
|
mesh.tri_face.push(0);
|
|
}
|
|
let mut scene = sphere_grid(white(), 2, 3);
|
|
scene.bounds = mesh.bounds();
|
|
scene.meshes[0].mesh = Arc::new(mesh);
|
|
let mut task = Task::new(context.clone(), scene, request(2), JobOptions::default(), CancelToken::default()).unwrap();
|
|
let mut params = vec![0; 32];
|
|
scene::vector(&mut params, bits(0x438a6e62, 0x4175ca91, 0xc2860000), 0.);
|
|
scene::vector(&mut params, bits(0xbedb21b8, 0xbebd05fd, 0x4295df13), 0.);
|
|
scene::vector(&mut params, bits(0x3f3519ed, 0x3f28acac, 0xbe82f446), 0.);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let values = task.read_linear().unwrap();
|
|
assert_eq!(values[0][0], 2.0, "hit/distance={:?}", values[0]);
|
|
assert!((f64::from(values[0][1]) - 2.615).abs() < 0.01, "hit/distance={:?}", values[0]);
|
|
}
|
|
#[test]
|
|
fn gpu_entry_at_a_shared_edge_does_not_reenter_the_adjacent_face() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context
|
|
.device
|
|
.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("edge entry oracle"), source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("continuation_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
let bits = |x: u32, y: u32, z: u32| Vec3::new(f64::from(f32::from_bits(x)), f64::from(f32::from_bits(y)), f64::from(f32::from_bits(z)));
|
|
// Captured tumbler faces: a refracted ray entered the glass through the first
|
|
// face 8e-9 (barycentric) from its edge with the second. Its reconstructed
|
|
// start is 6.5e-9 mm outside both planes, so it met the second face from
|
|
// outside 1.1e-8 mm later: an "entry" while already inside. A cone to an
|
|
// apex behind both faces closes the captured pair into valid closed glass.
|
|
let a = bits(0x43050000, 0x42095be6, 0x42140000);
|
|
let b = bits(0x4304aef7, 0x4218aea0, 0x41b80000);
|
|
let c = bits(0x4303bd40, 0x4205b1dd, 0x41b80000);
|
|
let e = bits(0x4305c374, 0x421b114d, 0x42140000);
|
|
let f = Vec3::new(140.75, 34.75, 29.5);
|
|
let faces = [[c, a, b], [e, b, a], [a, c, f], [e, a, f], [b, e, f], [c, b, f]];
|
|
let mut mesh = Mesh::default();
|
|
for face in faces {
|
|
let n = (face[1] - face[0]).cross(face[2] - face[0]).normalized().unwrap();
|
|
let i = mesh.positions.len() as u32;
|
|
mesh.positions.extend(face);
|
|
mesh.normals.extend([n; 3]);
|
|
mesh.triangles.push([i, i + 1, i + 2]);
|
|
mesh.tri_face.push(0);
|
|
}
|
|
let mut scene = glass_slab(false);
|
|
scene.bounds = mesh.bounds();
|
|
scene.meshes[0].mesh = Arc::new(mesh);
|
|
let mut task = Task::new(context.clone(), scene, request(2), JobOptions::default(), CancelToken::default()).unwrap();
|
|
let mut params = vec![0; 32];
|
|
scene::vector(&mut params, bits(0x43050000, 0x42095be6, 0x42140000), 1.);
|
|
scene::vector(&mut params, bits(0xbda74978, 0x3f7d0fd4, 0xc06735c3), 0.);
|
|
scene::vector(&mut params, bits(0x3f4ff9cf, 0x3f0c3c0f, 0xbe4c997d), 0.);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let values = task.read_linear().unwrap();
|
|
// The ray must leave through one of the closing faces, at a real distance.
|
|
assert!(values[0][0] >= 2.0 && values[0][0] < 6.0, "hit/distance={:?}", values[0]);
|
|
assert!(values[0][1] > 1e-3, "hit/distance={:?}", values[0]);
|
|
}
|
|
#[test]
|
|
fn gpu_long_ray_near_corner_refraction_keeps_real_exit() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
|
label: Some("refracted corner oracle"),
|
|
source: wgpu::ShaderSource::Wgsl(SHADER.into()),
|
|
});
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("refracted_corner_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
let origin = Vec3::new(f64::from(f32::from_bits(0x43ad5626)), f64::from(f32::from_bits(0x44737912)), f64::from(f32::from_bits(0xc2dd2710)));
|
|
let direction = Vec3::new(f64::from(f32::from_bits(0xbe341340)), f64::from(f32::from_bits(0xbf762fdb)), f64::from(f32::from_bits(0x3e577470)));
|
|
let ior = f64::from(1.586_f32);
|
|
let ni = direction.x / ior;
|
|
let nk = direction.z / ior;
|
|
let refracted = Vec3::new(ni, -(1.0 - ni * ni - nk * nk).sqrt(), nk);
|
|
let entry_distance = (80.0 - origin.y) / direction.y;
|
|
let entry_z = origin.z + direction.z * entry_distance;
|
|
let exit_distance = (85.0 - entry_z) / refracted.z;
|
|
// Independent f64 plane/refraction oracle: true entry clearance is ~21um.
|
|
assert!(85.0 - entry_z > 0.00002 && 85.0 - entry_z < 0.000022);
|
|
let faces = [
|
|
[[157., 0., 85.], [243., 0., 85.], [243., 80., 85.], [157., 80., 85.]],
|
|
[[157., 80., -86.], [243., 80., -86.], [243., 0., -86.], [157., 0., -86.]],
|
|
[[243., 80., -86.], [157., 80., -86.], [157., 80., 85.], [243., 80., 85.]],
|
|
[[157., 0., -86.], [243., 0., -86.], [243., 0., 85.], [157., 0., 85.]],
|
|
[[243., 0., -86.], [243., 80., -86.], [243., 80., 85.], [243., 0., 85.]],
|
|
[[157., 80., -86.], [157., 0., -86.], [157., 0., 85.], [157., 80., 85.]],
|
|
];
|
|
for permutation in [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]] {
|
|
let odd = (permutation[0] > permutation[1]) ^ (permutation[0] > permutation[2]) ^ (permutation[1] > permutation[2]);
|
|
for reflection in 0..8_u32 {
|
|
let sign = |axis: u32| if reflection & (1 << axis) == 0 { 1.0 } else { -1.0 };
|
|
let transform = |v: Vec3| {
|
|
let a = [v.x, v.y, v.z];
|
|
Vec3::new(a[permutation[0]] * sign(0), a[permutation[1]] * sign(1), a[permutation[2]] * sign(2))
|
|
};
|
|
let invert = odd ^ (reflection.count_ones() % 2 != 0);
|
|
let mut mesh = Mesh::default();
|
|
for face in faces {
|
|
for indices in [[0, 1, 2], [0, 2, 3]] {
|
|
let mut p = indices.map(|i| {
|
|
let a = face[i];
|
|
transform(Vec3::new(a[0], a[1], a[2]))
|
|
});
|
|
if invert {
|
|
p.swap(1, 2);
|
|
}
|
|
let n = (p[1] - p[0]).cross(p[2] - p[0]).normalized().unwrap();
|
|
let i = mesh.positions.len() as u32;
|
|
mesh.positions.extend(p);
|
|
mesh.normals.extend([n; 3]);
|
|
mesh.triangles.push([i, i + 1, i + 2]);
|
|
mesh.tri_face.push(0);
|
|
}
|
|
}
|
|
let mut scene = glass_slab(false);
|
|
scene.bounds = mesh.bounds();
|
|
scene.meshes[0].mesh = Arc::new(mesh);
|
|
scene.meshes[0].surface = Some(OpaqueSurface::new(Vec3::ZERO, 0., 0.1, ior).unwrap());
|
|
scene.meshes[0].transmission = Some(solidcraft_render::transmission::Transmission::new(Vec3::ZERO, None).unwrap());
|
|
let mut task = Task::new(context.clone(), scene, request(2), JobOptions::default(), CancelToken::default()).unwrap();
|
|
let mut params = vec![0; 32];
|
|
scene::vector(&mut params, transform(origin), 0.);
|
|
scene::vector(&mut params, transform(direction), 0.);
|
|
scene::vector(&mut params, Vec3::ZERO, 0.);
|
|
scene::vector(&mut params, Vec3::ZERO, 0.);
|
|
scene::vector(&mut params, Vec3::new(0.00084, 0., 0.), 0.);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let values = task.read_linear().unwrap();
|
|
assert_eq!(values[0], [1.; 4], "permutation={permutation:?} reflection={reflection}: {values:?}");
|
|
let z_axis = permutation.iter().position(|axis| *axis == 2).unwrap();
|
|
assert!(values[2][z_axis] < 85.0, "rounded entry onto top edge: {values:?}");
|
|
// Two position ULP at z85, propagated through the refracted angle.
|
|
let tolerance = 2.0 * f64::from(f32::from_bits(85.0_f32.to_bits() + 1) - 85.0) / refracted.z;
|
|
assert!(
|
|
(f64::from(values[1][0]) - exit_distance).abs() < tolerance,
|
|
"distance={:?} expected={exit_distance} tolerance={tolerance}",
|
|
values[1]
|
|
);
|
|
let expected = transform(refracted);
|
|
for (a, b) in values[3].iter().zip([expected.x, expected.y, expected.z]) {
|
|
assert!((f64::from(*a) - 2.0 - b).abs() < 2e-6);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[test]
|
|
fn gpu_rib_total_internal_reflection_retains_origin_residual() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context
|
|
.device
|
|
.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("rib residual oracle"), source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("rib_residual_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
let a = Vec3::new(-162., -53., -127.);
|
|
let b = Vec3::new(f64::from(-163.7_f32), -55., -55.);
|
|
let c = Vec3::new(f64::from(-163.7_f32), -55., -127.);
|
|
let other = Vec3::new(-165.5, -53., -55.);
|
|
let bary = Vec3::new(f64::from(f32::from_bits(0x369bafd4)), f64::from(f32::from_bits(0x3f59c40b)), f64::from(f32::from_bits(0x3e18ee9d)));
|
|
let incoming = Vec3::new(f64::from(f32::from_bits(0xbeba12cc)), f64::from(f32::from_bits(0xbf6e1a19)), f64::from(f32::from_bits(0xbd5b2b1e)));
|
|
// These are captured GPU barycentrics, not an idealized primary-ray hit.
|
|
let point = b + (a - b) * bary.x + (c - b) * bary.z;
|
|
let normal = (b - a).cross(c - a).normalized().unwrap();
|
|
let outgoing = incoming - normal * (2.0 * incoming.dot(normal));
|
|
let exit_normal = (other - b).cross(c - b).normalized().unwrap();
|
|
let expected = -(point - b).dot(exit_normal) / outgoing.dot(exit_normal);
|
|
assert!(expected > 1e-5 && expected < 1.5e-5);
|
|
let cross_section = [[-162., -53.], [f64::from(-163.7_f32), -55.], [-165.5, -53.]];
|
|
let mut faces = Vec::new();
|
|
let lower = cross_section.map(|p| Vec3::new(p[0], p[1], -127.));
|
|
let upper = cross_section.map(|p| Vec3::new(p[0], p[1], -55.));
|
|
faces.push(lower);
|
|
faces.push([upper[0], upper[2], upper[1]]);
|
|
for i in 0..3 {
|
|
let j = (i + 1) % 3;
|
|
faces.push([lower[i], upper[i], upper[j]]);
|
|
faces.push([lower[i], upper[j], lower[j]]);
|
|
}
|
|
for permutation in [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]] {
|
|
let odd = (permutation[0] > permutation[1]) ^ (permutation[0] > permutation[2]) ^ (permutation[1] > permutation[2]);
|
|
for reflection in 0..8_u32 {
|
|
let sign = |axis: u32| if reflection & (1 << axis) == 0 { 1.0 } else { -1.0 };
|
|
let transform = |v: Vec3| {
|
|
let a = [v.x, v.y, v.z];
|
|
Vec3::new(a[permutation[0]] * sign(0), a[permutation[1]] * sign(1), a[permutation[2]] * sign(2))
|
|
};
|
|
let invert = odd ^ (reflection.count_ones() % 2 != 0);
|
|
let mut mesh = Mesh::default();
|
|
for face in &faces {
|
|
let mut p = face.map(transform);
|
|
if invert {
|
|
p.swap(1, 2);
|
|
}
|
|
let n = (p[1] - p[0]).cross(p[2] - p[0]).normalized().unwrap();
|
|
let i = mesh.positions.len() as u32;
|
|
mesh.positions.extend(p);
|
|
mesh.normals.extend([n; 3]);
|
|
mesh.triangles.push([i, i + 1, i + 2]);
|
|
mesh.tri_face.push(0);
|
|
}
|
|
let mut scene = glass_slab(false);
|
|
scene.bounds = mesh.bounds();
|
|
scene.meshes[0].mesh = Arc::new(mesh);
|
|
scene.meshes[0].surface = Some(OpaqueSurface::new(Vec3::ZERO, 0., 0.1, f64::from(1.49_f32)).unwrap());
|
|
scene.meshes[0].transmission = Some(solidcraft_render::transmission::Transmission::new(Vec3::ZERO, None).unwrap());
|
|
let mut task = Task::new(context.clone(), scene, request(2), JobOptions::default(), CancelToken::default()).unwrap();
|
|
let mut params = vec![0; 32];
|
|
scene::vector(&mut params, transform(a), 0.);
|
|
scene::vector(&mut params, transform(if invert { c } else { b }), 0.);
|
|
scene::vector(&mut params, transform(if invert { b } else { c }), 0.);
|
|
scene::vector(&mut params, transform(incoming), 0.);
|
|
scene::vector(&mut params, Vec3::new(0.00084, 0., 0.), 0.);
|
|
scene::vector(&mut params, if invert { Vec3::new(bary.x, bary.z, bary.y) } else { bary }, 0.);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let values = task.read_linear().unwrap();
|
|
assert_eq!(values[0], [0., 1., 1., 1.], "permutation={permutation:?} reflection={reflection}: {values:?}");
|
|
assert_eq!(values[1][1], 1.0, "must be TIR: {values:?}");
|
|
assert!((f64::from(values[1][0]) - expected).abs() < 2e-7, "expected={expected}: {values:?}");
|
|
}
|
|
}
|
|
}
|
|
#[test]
|
|
fn gpu_integer_binary32_add_sub_matches_hardware_bits() {
|
|
use wgpu::util::DeviceExt;
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let mut pairs = Vec::new();
|
|
let fractions = [0, 1, 0x3fffff, 0x400000, 0x400001, 0x7ffffe, 0x7fffff];
|
|
for exponent in [0u32, 1, 2, 23, 24, 25, 31, 32, 63, 126, 127, 128, 253, 254, 255] {
|
|
for gap in [0, 1, 23, 24, 25, 31, 32, 63, 254] {
|
|
for a_fraction in fractions {
|
|
for b_fraction in fractions {
|
|
let a = exponent << 23 | a_fraction;
|
|
let b = exponent.saturating_sub(gap) << 23 | b_fraction;
|
|
pairs.extend([[a, b], [a ^ 0x80000000, b], [b, a], [b, a ^ 0x80000000]]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pairs.extend([[0x80000000, 0x80000000], [0, 0x80000000], [1, 0x80000001]]);
|
|
let mut state = 0x9e3779b9u32;
|
|
while pairs.len() < 65536 {
|
|
state = state.wrapping_mul(1664525).wrapping_add(1013904223);
|
|
let a = state;
|
|
state = state.wrapping_mul(1664525).wrapping_add(1013904223);
|
|
pairs.push([a, state]);
|
|
}
|
|
assert_eq!(pairs.len(), 65536);
|
|
let mut bytes = Vec::with_capacity(4 + pairs.len() * 8);
|
|
bytes.extend((pairs.len() as u32).to_le_bytes());
|
|
for pair in &pairs {
|
|
for word in pair {
|
|
bytes.extend(word.to_le_bytes());
|
|
}
|
|
}
|
|
let input = context.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
|
label: Some("integer binary32 inputs"),
|
|
contents: &bytes,
|
|
usage: wgpu::BufferUsages::STORAGE,
|
|
});
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
|
label: Some("integer binary32 oracle"),
|
|
source: wgpu::ShaderSource::Wgsl(SHADER.into()),
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: None,
|
|
module: &shader,
|
|
entry_point: Some("integer_float_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
let mut task = Task::new(context.clone(), glass_slab(false), request(256), JobOptions::default(), CancelToken::default()).unwrap();
|
|
let bind = context.device.create_bind_group(&wgpu::BindGroupDescriptor {
|
|
label: Some("integer binary32 oracle"),
|
|
layout: &pipeline.get_bind_group_layout(0),
|
|
entries: &[
|
|
wgpu::BindGroupEntry { binding: 1, resource: input.as_entire_binding() },
|
|
wgpu::BindGroupEntry { binding: 3, resource: task.accumulation.as_entire_binding() },
|
|
],
|
|
});
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &bind, &[]);
|
|
pass.dispatch_workgroups(1024, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let values = task.read_linear().unwrap();
|
|
let bits = |value: f32| if value.is_nan() { 0x7fc00000 } else { value.to_bits() };
|
|
for (i, ([a, b], value)) in pairs.iter().zip(values).enumerate() {
|
|
let a_float = f32::from_bits(*a);
|
|
let b_float = f32::from_bits(*b);
|
|
let sum = value[0] as u32 | (value[1] as u32) << 16;
|
|
let difference = value[2] as u32 | (value[3] as u32) << 16;
|
|
assert_eq!(sum, bits(a_float + b_float), "sum index={i} a={a:08x} b={b:08x}");
|
|
assert_eq!(difference, bits(a_float - b_float), "difference index={i} a={a:08x} b={b:08x}");
|
|
}
|
|
}
|
|
#[test]
|
|
fn gpu_emitter_short_segment_beer_and_area_pdf() {
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
|
label: Some("short emitter segment oracle"),
|
|
source: wgpu::ShaderSource::Wgsl(SHADER.into()),
|
|
});
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("emitter_segment_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
let mut task = Task::new(context.clone(), glass_slab(false), request(1), JobOptions::default(), CancelToken::default()).unwrap();
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let result = task.read_linear().unwrap()[0];
|
|
let ray = Vec3::new(f64::from(0.6f32), 0., f64::from(0.8f32));
|
|
let distance = f64::from(0.00001f32);
|
|
let length = ray.len() * distance;
|
|
let cosine = ray.z / ray.len();
|
|
let expected = [length, (-5000. * length).exp(), length * length / (16. * cosine)];
|
|
for i in 0..3 {
|
|
assert!((f64::from(result[i]) / expected[i] - 1.).abs() < 2e-6, "channel={i} expected={expected:?} result={result:?}");
|
|
}
|
|
}
|
|
#[test]
|
|
fn gpu_integer_relative_fast_paths_match_ordered_rounding() {
|
|
use wgpu::util::DeviceExt;
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let mut quads = Vec::new();
|
|
let fractions = [0, 1, 0x3fffff, 0x400000, 0x400001, 0x7ffffe, 0x7fffff];
|
|
for exponent in [0u32, 1, 2, 23, 24, 25, 126, 127, 128, 253, 254, 255] {
|
|
for fraction in fractions {
|
|
let a = exponent << 23 | fraction;
|
|
for b in [a, a ^ 1, a.wrapping_add(0x800000), a ^ 0x80000000, 0, 0x80000000] {
|
|
for offset in [0, 0x80000000, 1, 0x80000001, 0x3f800000, 0xbf800000, a, b] {
|
|
quads.extend([[a, 0, b, offset], [a, offset, b, 0], [a, offset, a, b], [a, b, b, a]]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let mut state = 0x12345678u32;
|
|
while quads.len() < 65536 {
|
|
let mut next = || {
|
|
state = state.wrapping_mul(1664525).wrapping_add(1013904223);
|
|
state
|
|
};
|
|
let mut quad = [next(), next(), next(), next()];
|
|
match quads.len() % 5 {
|
|
0 => quad[2] = quad[0],
|
|
1 => {
|
|
quad[1] = 0;
|
|
quad[3] = 0;
|
|
}
|
|
2 => quad[1] = 0,
|
|
3 => {
|
|
quad[0] = 0x3f800000 | (quad[0] & 0x7fffff);
|
|
quad[2] = quad[0] ^ 1;
|
|
}
|
|
_ => {}
|
|
}
|
|
quads.push(quad);
|
|
}
|
|
assert_eq!(quads.len(), 65536);
|
|
let mut bytes = Vec::with_capacity(4 + quads.len() * 16);
|
|
bytes.extend((quads.len() as u32).to_le_bytes());
|
|
for quad in &quads {
|
|
for word in quad {
|
|
bytes.extend(word.to_le_bytes());
|
|
}
|
|
}
|
|
let input = context.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
|
label: Some("relative coordinate inputs"),
|
|
contents: &bytes,
|
|
usage: wgpu::BufferUsages::STORAGE,
|
|
});
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
|
label: Some("relative coordinate oracle"),
|
|
source: wgpu::ShaderSource::Wgsl(SHADER.into()),
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: None,
|
|
module: &shader,
|
|
entry_point: Some("integer_relative_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
let mut task = Task::new(context.clone(), glass_slab(false), request(256), JobOptions::default(), CancelToken::default()).unwrap();
|
|
let bind = context.device.create_bind_group(&wgpu::BindGroupDescriptor {
|
|
label: Some("relative coordinate oracle"),
|
|
layout: &pipeline.get_bind_group_layout(0),
|
|
entries: &[
|
|
wgpu::BindGroupEntry { binding: 1, resource: input.as_entire_binding() },
|
|
wgpu::BindGroupEntry { binding: 3, resource: task.accumulation.as_entire_binding() },
|
|
],
|
|
});
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &bind, &[]);
|
|
pass.dispatch_workgroups(1024, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let values = task.read_linear().unwrap();
|
|
for (i, (quad, value)) in quads.iter().zip(values).enumerate() {
|
|
let reference = value[0] as u32 | (value[1] as u32) << 16;
|
|
let candidate = value[2] as u32 | (value[3] as u32) << 16;
|
|
let [a, al, b, bl] = quad.map(f32::from_bits);
|
|
let anchor = a - b;
|
|
let offset = al - bl;
|
|
let result = anchor + offset;
|
|
let expected = if result.is_nan() { 0x7fc00000 } else { result.to_bits() };
|
|
assert_eq!(reference, expected, "reference index={i} input={quad:08x?}");
|
|
assert_eq!(candidate, expected, "candidate index={i} input={quad:08x?}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn medium_failures_are_tolerated_only_when_rare() {
|
|
// One failure in one path (a camera inside glass) is never tolerated.
|
|
assert!(!medium_failures_tolerated(1, 1));
|
|
assert!(medium_failures_tolerated(0, 1));
|
|
assert!(medium_failures_tolerated(1, 1_000_000));
|
|
assert!(!medium_failures_tolerated(2, 1_000_000));
|
|
// 1080p at 256 spp tolerates up to 530 isolated paths.
|
|
assert!(medium_failures_tolerated(530, 1920 * 1080 * 256));
|
|
assert!(!medium_failures_tolerated(531, 1920 * 1080 * 256));
|
|
assert!(!medium_failures_tolerated(1_u64 << 32, 1_u64 << 32));
|
|
}
|
|
|
|
#[test]
|
|
fn identical_maps_pack_once_for_multiple_gpu_bodies() {
|
|
use solidcraft_render::job::textures::{PlanarFrame, RuntimeTextures};
|
|
let fixture = texture_fixture(PlanarFrame { origin: [0.0; 3], u: [2.0, 0.0, 0.0], v: [0.0, 2.0, 0.0] });
|
|
let first = fixture.bindings()[0].clone();
|
|
let mut second = first.clone();
|
|
second.body_index = 1;
|
|
second.body_name = "Second body".into();
|
|
let input = RuntimeTextures::new(vec![first, second]).unwrap();
|
|
let bytes = textures::flatten(Some(&input), 2, Vec3::ZERO, &CancelToken::default()).unwrap();
|
|
let word = |i: usize| u32::from_le_bytes(bytes[i * 4..i * 4 + 4].try_into().unwrap()) as usize;
|
|
let a = word(5);
|
|
let b = word(6);
|
|
assert_ne!(a, b, "bindings keep separate coordinate records");
|
|
assert_eq!(word(a + 3), word(b + 3), "one color payload");
|
|
assert_eq!(word(a + 12), word(b + 12), "one normal payload");
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_scalar_maps_match_linear_reference_without_touching_ior() {
|
|
use image::ImageEncoder;
|
|
use solidcraft_render::{
|
|
job::textures::{PlanarFrame, RuntimeTextures, TextureMap},
|
|
texture_input::MapRole,
|
|
};
|
|
let Some(executor) = executor() else { return };
|
|
let context = &executor.context;
|
|
let scalar = |value: u8, role| {
|
|
let mut bytes = Vec::new();
|
|
image::codecs::png::PngEncoder::new(&mut bytes).write_image(&[value, value, value, 255], 1, 1, image::ExtendedColorType::Rgba8).unwrap();
|
|
TextureMap::new(bytes, role).unwrap()
|
|
};
|
|
let fixture = texture_fixture(PlanarFrame { origin: [0.0; 3], u: [2.0, 0.0, 0.0], v: [0.0, 2.0, 0.0] });
|
|
let mut binding = fixture.bindings()[0].clone();
|
|
binding.base_color = None;
|
|
binding.normal = None;
|
|
binding.flip_v = true;
|
|
binding.roughness = Some(scalar(192, MapRole::Roughness));
|
|
binding.metallic = Some(scalar(64, MapRole::Metallic));
|
|
let source = Arc::new(RuntimeTextures::new(vec![binding]).unwrap());
|
|
let shader = context.device.create_shader_module(wgpu::ShaderModuleDescriptor { label: None, source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
|
|
let layout = context.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: None,
|
|
bind_group_layouts: &[Some(&context.layout)],
|
|
immediate_size: 0,
|
|
});
|
|
let pipeline = context.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
|
label: None,
|
|
layout: Some(&layout),
|
|
module: &shader,
|
|
entry_point: Some("texture_scalar_reference"),
|
|
compilation_options: Default::default(),
|
|
cache: None,
|
|
});
|
|
let mut input = request(2);
|
|
input.textures = Some(source);
|
|
// An explicit non-default optical fixture catches accidental IOR rewrites.
|
|
let original = OpaqueSurface::new(Vec3::new(0.2, 0.4, 0.6), 0.6, 0.2, 1.7).unwrap();
|
|
let mut task = Task::new(context.clone(), sphere(original), input, JobOptions::default(), CancelToken::default()).unwrap();
|
|
let mut params = vec![0; 32];
|
|
scene::vector(&mut params, Vec3::ZERO, 0.0);
|
|
scene::vector(&mut params, Vec3::ZERO, 0.0);
|
|
scene::vector(&mut params, Vec3::Z, 0.0);
|
|
scene::vector(&mut params, Vec3::Z, 0.0);
|
|
context.queue.write_buffer(&task.uniform, 0, ¶ms);
|
|
let mut encoder = context.device.create_command_encoder(&Default::default());
|
|
{
|
|
let mut pass = encoder.begin_compute_pass(&Default::default());
|
|
pass.set_pipeline(&pipeline);
|
|
pass.set_bind_group(0, &task.bind, &[]);
|
|
pass.dispatch_workgroups(1, 1, 1);
|
|
}
|
|
context.queue.submit([encoder.finish()]);
|
|
task.sample = 1;
|
|
let actual = task.read_linear().unwrap();
|
|
for (a, b) in actual[0].iter().zip([64.0 / 255.0, 192.0 / 255.0, original.dielectric_ior()]) {
|
|
assert!((f64::from(*a) - b).abs() < 2e-6, "scalar map {actual:?}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn production_envelope_is_device_bounded_and_never_silently_resized() {
|
|
let mut image = request(1);
|
|
image.width = 3840;
|
|
image.height = 2160;
|
|
let source = sphere(white());
|
|
let accepted = admission(&source, &image, JobOptions::default()).unwrap();
|
|
assert!(accepted.estimated_total_bytes < GPU_PATH_LIMITS.max_scratch_bytes);
|
|
assert_eq!(descriptor().unwrap().fit(3840, 2160), Some((3840, 2160)));
|
|
image.width = 8193;
|
|
assert!(admission(&source, &image, JobOptions::default()).is_err());
|
|
image.width = 8192;
|
|
image.height = 8192;
|
|
assert!(admission(&source, &image, JobOptions::default()).is_err());
|
|
let mut supported = wgpu::Limits::downlevel_defaults();
|
|
supported.max_storage_buffers_per_shader_stage = 8;
|
|
supported.max_storage_buffer_binding_size = 2 * 1024 * 1024 * 1024;
|
|
supported.max_buffer_size = 2 * 1024 * 1024 * 1024;
|
|
let limits = device_limits(supported.clone()).unwrap();
|
|
assert_eq!(limits.max_storage_buffer_binding_size, 1024 * 1024 * 1024);
|
|
assert!(limits.max_buffer_size <= supported.max_buffer_size);
|
|
}
|
|
|
|
#[test]
|
|
fn disjoint_glass_count_does_not_relax_closed_topology_or_overlap_validation() {
|
|
let template = sphere_grid(white(), 8, 16);
|
|
let mut source = ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY };
|
|
for i in 0..solidcraft_render::job::MAX_GPU_DIELECTRICS {
|
|
let mut body = template.meshes[0].clone();
|
|
body.name = format!("separate glass {i}");
|
|
for p in &mut Arc::make_mut(&mut body.mesh).positions {
|
|
p.x += i as f64 * 3.0;
|
|
}
|
|
body.transmission = Some(clear_glass());
|
|
source.bounds = source.bounds.union(&body.mesh.bounds());
|
|
source.meshes.push(body);
|
|
}
|
|
assert!(scene::flatten(&source, Vec3::ZERO, &CancelToken::default()).is_ok());
|
|
source.meshes.push(source.meshes[0].clone());
|
|
assert!(scene::flatten(&source, Vec3::ZERO, &CancelToken::default()).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn display_identity_matches_the_legacy_response_and_spatial_filters_ignore_chunking() {
|
|
use solidcraft_render::job::finishing::{Backdrop, BackdropMode, Finishing};
|
|
let cancel = CancelToken::default();
|
|
let input: Vec<[f32; 4]> = (0..91)
|
|
.map(|i| {
|
|
[
|
|
i as f32 * 0.15,
|
|
0.07,
|
|
0.8,
|
|
if i % 3 == 0 {
|
|
0.0
|
|
} else if i % 3 == 1 {
|
|
0.5
|
|
} else {
|
|
1.0
|
|
},
|
|
]
|
|
})
|
|
.collect();
|
|
let display = Display {
|
|
finishing: Finishing::default(),
|
|
backdrop: None,
|
|
width: 13,
|
|
height: 7,
|
|
exposure: 1.3,
|
|
tone_map: ToneMap::Reinhard,
|
|
background: [0.02, 0.05, 0.12],
|
|
transparent: false,
|
|
};
|
|
let mut reference = Vec::new();
|
|
for pixel in &input {
|
|
let alpha = f64::from(pixel[3]);
|
|
for (radiance, background) in pixel.iter().take(3).zip(display.background) {
|
|
let c = if alpha > 0.0 { f64::from(*radiance) * display.exposure / alpha } else { 0.0 };
|
|
let value = display.tone_map.map(c) * alpha + background * (1.0 - alpha);
|
|
let encoded = if value <= 0.0031308 { value * 12.92 } else { 1.055 * value.powf(1.0 / 2.4) - 0.055 };
|
|
reference.push((encoded.clamp(0.0, 1.0) * 255.0).round() as u8);
|
|
}
|
|
reference.push(255);
|
|
}
|
|
let mut neutral = vec![0; input.len() * 4];
|
|
display.encode(&input, &mut neutral, &cancel).unwrap();
|
|
assert_eq!(neutral, reference);
|
|
let changed = Display {
|
|
finishing: Finishing { rgb_gain: [1.2, 0.9, 0.7], contrast: 1.2, saturation: 0.3, vignette: 0.45, ..Default::default() },
|
|
backdrop: Some(Backdrop { mode: BackdropMode::Radial, ..Default::default() }),
|
|
..display
|
|
};
|
|
let mut all = vec![0; input.len() * 4];
|
|
changed.encode(&input, &mut all, &cancel).unwrap();
|
|
for chunk in [1, 5, 13, 90] {
|
|
let mut split = vec![0; all.len()];
|
|
for (index, (pixels, output)) in input.chunks(chunk).zip(split.chunks_mut(chunk * 4)).enumerate() {
|
|
changed.encode_at(pixels, output, &cancel, index * chunk).unwrap();
|
|
}
|
|
assert_eq!(all, split, "chunk {chunk} must preserve absolute vignette/backdrop position");
|
|
}
|
|
assert_ne!(all, neutral);
|
|
}
|
|
|
|
fn complete_linear_fixture(context: Arc<Context>, options: JobOptions) -> (Vec<u8>, Option<Vec<u8>>) {
|
|
// Use the public environment-lighting contract, not the test-only numerical
|
|
// furnace path. Primary misses remain transparent black in the linear master.
|
|
let options = JobOptions {
|
|
lighting: Some(solidcraft_render::job::StudioLighting { environment: [8.0; 3], sun: None, area_lights: Default::default() }),
|
|
..options
|
|
};
|
|
let mut task = Task::new(context, sphere(white()), request(16), options, CancelToken::default()).unwrap();
|
|
for _ in 0..5000 {
|
|
match task.step(16384).unwrap() {
|
|
TaskPoll::Pending(_) => {}
|
|
TaskPoll::Complete(png) => {
|
|
let exr = task.take_linear_exr();
|
|
assert!(task.take_linear_exr().is_none(), "linear master moves exactly once");
|
|
return (png, exr);
|
|
}
|
|
}
|
|
}
|
|
panic!("bounded linear-output fixture did not finish")
|
|
}
|
|
#[test]
|
|
fn gpu_raw_master_keeps_hdr_samples_before_denoise_gain_tone_and_camera_backdrop() {
|
|
use solidcraft_render::job::finishing::{Backdrop, Finishing};
|
|
let Some(executor) = executor() else {
|
|
return;
|
|
};
|
|
let options = JobOptions { samples: 16, seed: 17, max_depth: 3, ..Default::default() };
|
|
let (png, none) = complete_linear_fixture(executor.context.clone(), options);
|
|
assert!(none.is_none());
|
|
let (retained, raw) = complete_linear_fixture(executor.context.clone(), JobOptions { linear_exr: true, ..options });
|
|
assert_eq!(png, retained, "opting into raw retention does not change display pixels");
|
|
let raw = raw.unwrap();
|
|
let (filtered, other) = complete_linear_fixture(
|
|
executor.context.clone(),
|
|
JobOptions {
|
|
linear_exr: true,
|
|
denoise: true,
|
|
exposure_ev: -2.0,
|
|
tone_map: ToneMap::AcesFitted,
|
|
finishing: Finishing { rgb_gain: [1.4, 0.8, 0.6], saturation: 0.2, vignette: 0.4, ..Default::default() },
|
|
backdrop: Some(Backdrop::default()),
|
|
..options
|
|
},
|
|
);
|
|
assert_eq!(raw, other.unwrap(), "raw sample values precede every presentation adjustment");
|
|
assert_ne!(png, filtered);
|
|
// Parse attributes/offsets independently to check real HDR data > display white.
|
|
let mut cursor = 8;
|
|
while raw[cursor] != 0 {
|
|
while raw[cursor] != 0 {
|
|
cursor += 1;
|
|
}
|
|
cursor += 1;
|
|
while raw[cursor] != 0 {
|
|
cursor += 1;
|
|
}
|
|
cursor += 1;
|
|
let size = i32::from_le_bytes(raw[cursor..cursor + 4].try_into().unwrap()) as usize;
|
|
cursor += 4 + size;
|
|
}
|
|
cursor += 1;
|
|
let mut maximum = 0_f32;
|
|
for y in 0..16 {
|
|
let offset = u64::from_le_bytes(raw[cursor + y * 8..cursor + y * 8 + 8].try_into().unwrap()) as usize;
|
|
for bytes in raw[offset + 8 + 64..offset + 8 + 256].as_chunks::<4>().0 {
|
|
maximum = maximum.max(f32::from_le_bytes(*bytes));
|
|
}
|
|
}
|
|
assert!(maximum > 2.0, "raw highlight radiance must not be clipped or reconstructed from PNG: {maximum}");
|
|
// Optional fresh external evidence folder for an independent OpenEXR reader.
|
|
if let Some(out) = std::env::var_os("SOLIDCRAFT_FINISHING_EVIDENCE_DIR") {
|
|
let out = std::path::PathBuf::from(out);
|
|
assert!(out.is_absolute() && !out.exists());
|
|
std::fs::create_dir_all(&out).unwrap();
|
|
std::fs::write(out.join("raw-radiance.exr"), &raw).unwrap();
|
|
std::fs::write(out.join("neutral.png"), &png).unwrap();
|
|
std::fs::write(out.join("filtered.png"), &filtered).unwrap();
|
|
std::fs::write(
|
|
out.join("expected.json"),
|
|
serde_json::to_vec_pretty(&serde_json::json!({"width":16,"height":16,
|
|
"maximum_raw_rgb":maximum,"raw_identical_before_after_finishing":true,"png_neutral_identity":true,
|
|
"rgba_type":"FLOAT","encoding":"scene-linear sRGB/D65","alpha":"coverage-premultiplied"}))
|
|
.unwrap(),
|
|
)
|
|
.unwrap();
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_host_retains_linear_companion_under_the_same_exact_frame_lease() {
|
|
use solidcraft_render::job::{JobId, Phase};
|
|
let Some(executor) = executor() else {
|
|
return;
|
|
};
|
|
let host = ImageHost::with_executor(Arc::new(executor)).unwrap();
|
|
let id = JobId { session: 999, serial: 1, generation: 42 };
|
|
let source = sphere(white());
|
|
let req = request(8);
|
|
let base = host.admit(&source, &req, JobOptions::default()).unwrap();
|
|
let options = JobOptions { samples: 4, linear_exr: true, ..Default::default() };
|
|
let extra = host.admit(&source, &req, options).unwrap();
|
|
assert_eq!(extra.estimated_total_bytes - base.estimated_total_bytes, solidcraft_render::job::linear_exr::encoded_limit(8, 8).unwrap());
|
|
let handle = host.submit_with_options(id, 7, source.clone(), req.clone(), options).unwrap();
|
|
let status = handle.wait_timeout(std::time::Duration::from_secs(30)).unwrap();
|
|
assert_eq!(status.progress.phase, Phase::Completed, "{:?}", status.error);
|
|
let frame = handle.frame().unwrap().unwrap();
|
|
let bytes = frame.linear_exr().unwrap();
|
|
assert_eq!(frame.linear_master_info().unwrap().bytes, bytes.len() as u64);
|
|
assert_eq!(status.linear_master.unwrap().sha256, frame.linear_master_info().unwrap().sha256);
|
|
assert!(host.admitted_bytes() >= frame.png().len() as u64 + bytes.len() as u64);
|
|
drop(handle);
|
|
assert!(host.admitted_bytes() > 0);
|
|
drop(frame);
|
|
// Cancellation/completion notification and worker-owned resource destruction
|
|
// are distinct events. Require the actual reservation to drain, without
|
|
// forcing premature release or changing the host's asynchronous contract.
|
|
let released_by = std::time::Instant::now() + std::time::Duration::from_secs(5);
|
|
while host.admitted_bytes() != 0 {
|
|
assert!(std::time::Instant::now() < released_by, "worker did not release its completed/cancelled reservation");
|
|
std::thread::sleep(std::time::Duration::from_millis(1));
|
|
}
|
|
assert_eq!(host.admitted_bytes(), 0);
|
|
let handle = host.submit_with_options(JobId { serial: 2, ..id }, 7, source, req, JobOptions { samples: 4096, ..options }).unwrap();
|
|
handle.cancel().unwrap();
|
|
let status = handle.wait_timeout(std::time::Duration::from_secs(30)).unwrap();
|
|
assert_eq!(status.progress.phase, Phase::Cancelled);
|
|
assert!(handle.frame().unwrap().is_none());
|
|
drop(handle);
|
|
// Cancellation/completion notification and worker-owned resource destruction
|
|
// are distinct events. Require the actual reservation to drain, without
|
|
// forcing premature release or changing the host's asynchronous contract.
|
|
let released_by = std::time::Instant::now() + std::time::Duration::from_secs(5);
|
|
while host.admitted_bytes() != 0 {
|
|
assert!(std::time::Instant::now() < released_by, "worker did not release its completed/cancelled reservation");
|
|
std::thread::sleep(std::time::Duration::from_millis(1));
|
|
}
|
|
assert_eq!(host.admitted_bytes(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn engine_exports_raw_master_from_the_exact_completed_job_without_png_conversion() {
|
|
use serde_json::json;
|
|
use solidcraft_render::job::{JobId, Phase};
|
|
let Some(executor) = executor() else {
|
|
return;
|
|
};
|
|
let host = ImageHost::with_executor(Arc::new(executor)).unwrap();
|
|
let mut s = solidcraft_engine::Session::default();
|
|
s.register_render_job_host(host.clone()).unwrap();
|
|
s.execute("solid.box", &json!({"length":2,"width":2,"height":1,"body_name":"Original output fixture"})).unwrap();
|
|
let before = s.doc.to_json();
|
|
let p = json!({"progressive":true,"samples":4,"linear_exr":true,"settings":{"width":12,"height":8},
|
|
"finishing":{"saturation":0.4},"backdrop":{"mode":"horizontal"}});
|
|
let checked = s.execute("render.preflight", &p).unwrap();
|
|
assert_eq!(checked["options"]["linear_exr"], true);
|
|
let started = s.execute("render.start", &p).unwrap();
|
|
let id: JobId = serde_json::from_value(started["job"].clone()).unwrap();
|
|
let handle = s.render_job_handle(id).unwrap();
|
|
assert_eq!(handle.wait_timeout(std::time::Duration::from_secs(30)).unwrap().progress.phase, Phase::Completed);
|
|
let frame = handle.frame().unwrap().unwrap();
|
|
let root = std::env::temp_dir().join(format!(
|
|
"solidcraft-linear-export-{}-{}",
|
|
std::process::id(),
|
|
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
|
|
));
|
|
std::fs::create_dir(&root).unwrap();
|
|
let path = root.join("raw.exr");
|
|
let png = root.join("display.png");
|
|
let output = s.execute("render.export", &json!({"job":id,"path":path,"format":"exr"})).unwrap();
|
|
assert_eq!(std::fs::read(&path).unwrap(), frame.linear_exr().unwrap());
|
|
assert_eq!(output["linear_master"]["sha256"], frame.linear_master_info().unwrap().sha256);
|
|
assert_eq!(output["encoding"], "scene_linear_srgb_d65");
|
|
assert_eq!(output["alpha"], "coverage_premultiplied");
|
|
assert_eq!(output["linear_master"]["encoding"], output["encoding"]);
|
|
s.execute("render.export", &json!({"job":id,"path":png})).unwrap();
|
|
assert_eq!(std::fs::read(&png).unwrap(), frame.png());
|
|
assert!(s.execute("render.export", &json!({"job":id,"path":path,"format":"exr"})).is_err());
|
|
assert!(s.execute("render.export", &json!({"job":id,"path":path,"format":"png","overwrite":true})).is_err());
|
|
assert_eq!(std::fs::read(&path).unwrap(), frame.linear_exr().unwrap());
|
|
assert!(s.execute("render.export", &json!({"job":JobId{session:id.session+1,..id},"path":root.join("wrong.exr"),"format":"exr"})).is_err());
|
|
assert!(!root.join("wrong.exr").exists());
|
|
assert_eq!(s.doc.to_json(), before);
|
|
drop(s);
|
|
drop(handle);
|
|
assert!(host.admitted_bytes() > 0);
|
|
drop(frame);
|
|
assert_eq!(host.admitted_bytes(), 0);
|
|
std::fs::remove_dir_all(root).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn gpu_bloom_changes_display_only_with_explicit_scratch_and_opaque_contract() {
|
|
use solidcraft_render::job::{bloom::Bloom, finishing::Finishing};
|
|
let Some(executor) = executor() else { return };
|
|
let options = JobOptions { samples: 16, seed: 17, max_depth: 3, linear_exr: true, ..Default::default() };
|
|
let (png, raw) = complete_linear_fixture(executor.context.clone(), options);
|
|
let bloom = Bloom { strength: 0.4, threshold: 1.0, radius: 2 };
|
|
let modified = JobOptions { finishing: Finishing { bloom: Some(bloom), ..Default::default() }, ..options };
|
|
let a = admission(&sphere(white()), &request(16), options).unwrap();
|
|
let b = admission(&sphere(white()), &request(16), modified).unwrap();
|
|
assert_eq!(b.estimated_total_bytes - a.estimated_total_bytes, 16 * 16 * 24);
|
|
assert_eq!(b.pixel_scratch_bytes - a.pixel_scratch_bytes, 16 * 16 * 24);
|
|
let (glowing, untouched) = complete_linear_fixture(executor.context.clone(), modified);
|
|
assert_eq!(raw, untouched, "bloom cannot alter the retained linear master or original estimator");
|
|
assert_ne!(png, glowing);
|
|
let (neutral, same) = complete_linear_fixture(
|
|
executor.context.clone(),
|
|
JobOptions { finishing: Finishing { bloom: Some(Bloom { strength: 0.0, ..bloom }), ..Default::default() }, ..options },
|
|
);
|
|
assert_eq!(png, neutral);
|
|
assert_eq!(raw, same);
|
|
let transparent = ImageRequest { transparent_background: true, ..request(16) };
|
|
assert!(executor.admit(&sphere(white()), &transparent, modified).is_err());
|
|
let decoded = image::load_from_memory(&glowing).unwrap().to_rgba8();
|
|
assert!(decoded.pixels().all(|p| p.0[3] == 255));
|
|
}
|
|
|
|
#[path = "adaptive_tests.rs"]
|
|
mod adaptive_tests;
|
|
|
|
#[path = "regrade_tests.rs"]
|
|
mod regrade_tests;
|
|
#[path = "volume_tests.rs"]
|
|
mod volume_tests;
|
|
|
|
#[path = "resource_pack_tests.rs"]
|
|
mod resource_pack_tests;
|
|
|
|
#[path = "optical_media_tests.rs"]
|
|
mod optical_media_tests;
|
|
|
|
#[path = "effects_tests.rs"]
|
|
mod effects_tests;
|
|
|
|
#[test]
|
|
fn display_bloom_slices_refuse_invalid_ranges_without_panicking() {
|
|
let pixels = [[1.0_f32, 2.0, 3.0]; 3];
|
|
assert_eq!(bloom_chunk(Some(&pixels), 1, 2).unwrap().unwrap(), &pixels[1..3]);
|
|
assert!(bloom_chunk(Some(&pixels), 3, 0).unwrap().unwrap().is_empty());
|
|
for (offset, count) in [(0, 4), (2, 2), (4, 0), (usize::MAX, 1), (1, usize::MAX)] {
|
|
let result = std::panic::catch_unwind(|| bloom_chunk(Some(&pixels), offset, count));
|
|
assert!(result.expect("invalid retained image range must not panic").is_err());
|
|
}
|
|
assert!(bloom_chunk(None, 0, 3).unwrap().is_none());
|
|
}
|
|
|
|
/// Cancellation in fallible HDR preparation must not drop three wgpu scopes in
|
|
/// forward order. Exercise the real preparation routine inside the guarded path,
|
|
/// then prove that the same device still accepts a fresh nested scope stack.
|
|
#[test]
|
|
fn cancelled_environment_preparation_unwinds_gpu_error_scopes() {
|
|
use solidcraft_render::lighting::environment::EnvironmentSource;
|
|
let Ok((_, device, _queue)) = open_headless() else {
|
|
let available = !crate::select::path_backends().is_empty();
|
|
assert!(!available || std::env::var_os("SOLIDCRAFT_REQUIRE_GPU").is_none(), "required Vulkan device unavailable");
|
|
return;
|
|
};
|
|
let mut image = request(1);
|
|
image.environment = Some(Arc::new(EnvironmentSource::hdr(original_hdr(), 0.0, 1.0, false).unwrap()));
|
|
let token = CancelToken::default();
|
|
let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
|
|
checked_creation(&device, || {
|
|
token.cancel();
|
|
prepare_environment(&image, &token)
|
|
})
|
|
}));
|
|
let error = outcome.expect("ordinary cancellation must not panic").unwrap_err();
|
|
assert_eq!(error.code, ErrorCode::Cancelled);
|
|
checked(scopes(&device)).unwrap();
|
|
let bytes = prepare_environment(&image, &CancelToken::default()).unwrap();
|
|
let info = image.environment.as_ref().unwrap().info();
|
|
assert_eq!(bytes.len(), 16 + info.width as usize * info.height as usize * 32);
|
|
}
|
|
|
|
/// A denoiser allocation can fail after the outer resource scopes were opened.
|
|
/// Preserve its Result while draining every scope, not only the last one.
|
|
#[test]
|
|
fn failed_resource_creation_unwinds_gpu_error_scopes() {
|
|
let Ok((_, device, _queue)) = open_headless() else {
|
|
let available = !crate::select::path_backends().is_empty();
|
|
assert!(!available || std::env::var_os("SOLIDCRAFT_REQUIRE_GPU").is_none(), "required Vulkan device unavailable");
|
|
return;
|
|
};
|
|
let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
|
|
checked_creation(&device, || -> Result<()> { Err(JobError::new(ErrorCode::LimitExceeded, "synthetic bounded allocation refusal")) })
|
|
}));
|
|
let error = outcome.expect("ordinary allocation refusal must not panic").unwrap_err();
|
|
assert_eq!(error.code, ErrorCode::LimitExceeded);
|
|
checked(scopes(&device)).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn actual_first_gpu_quantum_is_small_and_cancellation_retains_no_completed_image() {
|
|
let Some(executor) = executor() else { return };
|
|
let token = CancelToken::default();
|
|
let mut task = Task::new(executor.context.clone(), sphere(white()), request(64), JobOptions::default(), token.clone()).unwrap();
|
|
task.dispatch().unwrap();
|
|
assert_eq!(task.offset, dispatch::MIN_PATHS);
|
|
assert_eq!(task.sample, 0);
|
|
token.cancel();
|
|
assert_eq!(task.step(4096).err().unwrap().code, ErrorCode::Cancelled);
|
|
assert!(task.png.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn real_device_loss_retires_the_executor_and_the_sessions_cached_availability() {
|
|
use solidcraft_engine::Session;
|
|
let Some(executor) = executor() else { return };
|
|
let context = executor.context.clone();
|
|
let host = ImageHost::with_executor(Arc::new(executor)).unwrap();
|
|
let mut session = Session::default();
|
|
session.register_render_job_host(host.clone()).unwrap();
|
|
assert!(matches!(host.descriptor().unwrap().availability, Availability::Available));
|
|
context.device.destroy();
|
|
let deadline = Instant::now() + Duration::from_secs(2);
|
|
while context.healthy.load(Ordering::Acquire) && Instant::now() < deadline {
|
|
let _ = context.device.poll(wgpu::PollType::Poll);
|
|
std::thread::yield_now();
|
|
}
|
|
assert!(!context.healthy.load(Ordering::Acquire), "actual device-loss callback must retire the host");
|
|
assert!(matches!(host.descriptor().unwrap().availability, Availability::Unavailable { .. }));
|
|
let scene = sphere(white());
|
|
assert_eq!(host.admit(&scene, &request(1), JobOptions::default()).unwrap_err().code, ErrorCode::HostUnavailable);
|
|
let backend = session.render_backend();
|
|
assert!(backend.executors.iter().any(|d| d.id.as_str() == "gpu-path" && matches!(d.availability, Availability::Unavailable { .. })));
|
|
}
|