SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
use super::super::{Executor, JobOptions, Task, open_headless};
use super::*;
use solidcore_record::Vec3;
use solidcraft_geom::Mesh;
use solidcraft_render::{
Camera, ProductMesh, ProductScene, StandardView,
job::{CancelToken, ImageRequest, ImageWork, TaskPoll},
surface::OpaqueSurface,
};
use std::sync::Arc;
type Guide = [[f64; 4]; 3];
fn dot(a: [f64; 3], b: [f64; 3]) -> f64 {
a.into_iter().zip(b).map(|(x, y)| x * y).sum()
}
fn diff(a: [f64; 4], b: [f64; 4]) -> [f64; 3] {
[a[0] - b[0], a[1] - b[1], a[2] - b[2]]
}
fn xyz(a: [f64; 4]) -> [f64; 3] {
[a[0], a[1], a[2]]
}
// Independent f64 gather oracle: all inputs are averaged linear values, so the
// GPU's accumulated-sample scaling is absent from this numerical implementation.
fn reference(width: usize, input: &[[f64; 4]], guides: &[Guide], step: usize) -> Vec<[f64; 4]> {
let height = input.len() / width;
let kernel = [1.0, 4.0, 6.0, 4.0, 1.0];
input
.iter()
.enumerate()
.map(|(i, ¢er)| {
let [a, n, p] = guides[i];
if a[3] == 0.0 || center[3] < 0.999 {
return center;
}
let mut result = [0.0; 4];
let mut total = 0.0;
for (ky, &wy) in kernel.iter().enumerate() {
for (kx, &wx) in kernel.iter().enumerate() {
let x = (i % width) as isize + (kx as isize - 2) * step as isize;
let y = (i / width) as isize + (ky as isize - 2) * step as isize;
if x < 0 || y < 0 || x >= width as isize || y >= height as isize {
continue;
}
let j = y as usize * width + x as usize;
let [b, m, q] = guides[j];
let value = input[j];
if a[3] != b[3] || (value[3] - center[3]).abs() > 0.01 {
continue;
}
let albedo = diff(a, b);
let position = diff(q, p);
let plane = dot(position, xyz(n)).abs() + dot(position, xyz(m)).abs();
let scale = (0.05 * p[3].max(q[3]) * step as f64).max(1e-6);
let depth = (n[3] - m[3]).abs() / (8.0 * p[3].max(q[3]) * step as f64).max(1e-6);
let color = diff(center, value);
let maximum = |v: [f64; 3]| v.into_iter().fold(0.0, f64::max);
let color_scale = 0.25 + 0.5 * maximum(xyz(center)).max(maximum(xyz(value)));
let weight = wx
* wy
* (-dot(albedo, albedo) / 0.04 - plane / scale - depth - maximum(color.map(f64::abs)) / color_scale).exp()
* dot(xyz(n), xyz(m)).max(0.0).powi(32);
for k in 0..3 {
result[k] += value[k] * weight;
}
total += weight;
}
}
for v in result.iter_mut().take(3) {
*v /= total;
}
result[3] = center[3];
result
})
.collect()
}
fn guide(x: usize, y: usize) -> Guide {
[[0.5, 0.5, 0.5, 1.0], [0.0, 0.0, 1.0, 4.0], [x as f64, y as f64, 0.0, 1.0]]
}
fn fixture(size: usize) -> (Vec<[f64; 4]>, Vec<Guide>) {
let mut pixels = Vec::new();
let mut guides = Vec::new();
for y in 0..size {
for x in 0..size {
// Deterministic white noise in [0.4, 0.6]. A pixel-frequency checker would
// be invisible to the step-2 and step-4 passes, which only reach same-parity pixels.
let hash = ((x * 7919 + y * 104_729) as u64).wrapping_mul(0x9e37_79b9_7f4a_7c15) >> 40;
let level = 0.4 + 0.2 * hash as f64 / f64::from(1u32 << 24);
pixels.push([level, level, level, 1.0]);
guides.push(guide(x, y));
}
}
(pixels, guides)
}
#[test]
fn f64_atrous_reduces_flat_noise_preserves_constant_and_coverage() {
let (input, guides) = fixture(17);
let mut result = input.clone();
for step in [1, 2, 4] {
result = reference(17, &result, &guides, step);
}
let variance = |image: &[[f64; 4]]| {
let mean = image.iter().map(|p| p[0]).sum::<f64>() / image.len() as f64;
image.iter().map(|p| (p[0] - mean).powi(2)).sum::<f64>() / image.len() as f64
};
println!("noise variance {} -> {}", variance(&input), variance(&result));
assert!(variance(&result) < variance(&input) / 4.0, "noise variance {} -> {}", variance(&input), variance(&result));
assert_eq!(reference(17, &vec![[0.7, 0.3, 0.1, 0.5]; 289], &guides, 1), vec![[0.7, 0.3, 0.1, 0.5]; 289]);
let constant = reference(17, &vec![[0.75, 0.75, 0.75, 1.0]; 289], &guides, 4);
assert!(constant.iter().all(|p| p[..3].iter().all(|x| (*x - 0.75).abs() < 1e-14)));
}
#[test]
fn f64_atrous_preserves_body_normal_depth_and_albedo_edges() {
for edge in 0..5 {
let mut pixels = Vec::new();
let mut guides = Vec::new();
for y in 0..17 {
for x in 0..17 {
let mut g = guide(x, y);
let c = if x < 8 { 0.0 } else { 1.0 };
if x >= 8 {
match edge {
0 => g[0][3] = 2.0,
1 => g[1] = [1.0, 0.0, 0.0, 4.0],
2 => g[2][2] = 10.0,
4 => g[1][3] = 1004.0,
_ => g[0] = [1.0, 1.0, 1.0, 1.0],
}
}
if edge == 3 && x < 8 {
g[0] = [0.0, 0.0, 0.0, 1.0];
}
pixels.push([c, c, c, 1.0]);
guides.push(g);
}
}
let mut filtered = pixels.clone();
for step in [1, 2, 4] {
filtered = reference(17, &filtered, &guides, step);
}
assert!(filtered.iter().zip(&pixels).all(|(a, b)| (a[0] - b[0]).abs() < 1e-12), "edge {edge}");
}
}
fn context() -> Option<Arc<Context>> {
let (_, device, queue) = match open_headless() {
Ok(v) => v,
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}");
return None;
}
};
Some(Executor::new(device, queue).unwrap().context)
}
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,
camera,
width: size,
height: size,
background: [0; 3],
transparent_background: false,
environment: None,
textures: None,
}
}
fn plane() -> ProductScene {
let mesh = Mesh {
positions: vec![Vec3::new(-1.0, -1.0, 0.0), Vec3::new(1.0, -1.0, 0.0), Vec3::new(1.0, 1.0, 0.0), Vec3::new(-1.0, 1.0, 0.0)],
normals: vec![Vec3::Z; 4],
triangles: vec![[0, 1, 2], [0, 2, 3]],
tri_face: vec![0, 0],
..Default::default()
};
ProductScene {
bounds: mesh.bounds(),
meshes: vec![ProductMesh {
name: "original denoise plane".into(),
mesh: Arc::new(mesh),
color: [255; 3],
opacity: 1.0,
surface: Some(OpaqueSurface::new(Vec3::new(0.5, 0.5, 0.5), 0.0, 1.0, 1.5).unwrap()),
transmission: None,
faces: Vec::new(),
}],
}
}
fn read_guides(context: &Context, buffer: &wgpu::Buffer) -> Vec<[f32; 4]> {
let staging = context.device.create_buffer(&wgpu::BufferDescriptor {
label: None,
size: buffer.size(),
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let mut encoder = context.device.create_command_encoder(&Default::default());
encoder.copy_buffer_to_buffer(buffer, 0, &staging, 0, buffer.size());
let submission = context.queue.submit([encoder.finish()]);
let (tx, rx) = std::sync::mpsc::channel();
staging.slice(..).map_async(wgpu::MapMode::Read, move |v| {
tx.send(v).unwrap();
});
context.device.poll(wgpu::PollType::Wait { submission_index: Some(submission), timeout: Some(TIMEOUT) }).unwrap();
rx.recv().unwrap().unwrap();
let mapped = staging.slice(..).get_mapped_range().unwrap();
let values = mapped.as_chunks::<16>().0.iter().map(|v| [0, 4, 8, 12].map(|i| f32::from_le_bytes(v[i..i + 4].try_into().unwrap()))).collect();
drop(mapped);
staging.unmap();
values
}
#[test]
fn denoise_admission_counts_guides_and_ping_pong_only_when_enabled() {
let scene = plane();
let request = request(32);
let plain = super::super::admission(&scene, &request, JobOptions::default()).unwrap();
let filtered = super::super::admission(&scene, &request, JobOptions { denoise: true, ..Default::default() }).unwrap();
assert_eq!(filtered.pixel_scratch_bytes - plain.pixel_scratch_bytes, 32 * 32 * 80);
assert_eq!(filtered.estimated_total_bytes - plain.estimated_total_bytes, 32 * 32 * 80);
let large = ImageRequest { width: 2000, height: 2000, ..request.clone() };
assert!(super::super::admission(&scene, &large, JobOptions::default()).is_ok());
// The production envelope deliberately admits this former 512 MiB refusal.
// Still charge the guides/ping-pong in full, and reject outside the new edge.
let large_plain = super::super::admission(&scene, &large, JobOptions::default()).unwrap();
let large_filtered = super::super::admission(&scene, &large, JobOptions { denoise: true, ..Default::default() }).unwrap();
assert_eq!(large_filtered.pixel_scratch_bytes - large_plain.pixel_scratch_bytes, 2000 * 2000 * 80);
assert!(large_filtered.estimated_total_bytes > 512 * 1024 * 1024);
assert!(large_filtered.estimated_total_bytes <= solidcraft_render::job::GPU_PATH_LIMITS.max_scratch_bytes);
let excessive = ImageRequest { width: (solidcraft_render::job::GPU_PATH_LIMITS.max_dimension + 1) as u32, ..request.clone() };
for denoise in [false, true] {
assert!(super::super::admission(&scene, &excessive, JobOptions { denoise, ..Default::default() }).is_err());
}
assert!(!serde_json::from_str::<JobOptions>("{}").unwrap().denoise);
assert!(serde_json::from_str::<JobOptions>(r#"{"denoise":"true"}"#).is_err());
}
#[test]
fn gpu_atrous_matches_f64_guides_and_leaves_input_unchanged() {
let Some(context) = context() else {
return;
};
let (mut input, mut guides) = fixture(13);
for y in 0..13 {
for x in 7..13 {
guides[y * 13 + x][0][3] = 2.0;
input[y * 13 + x][0] += 0.8;
}
}
guides[0][0][3] = 0.0;
input[1][3] = 0.5;
let bytes: Vec<u8> = input.iter().flatten().flat_map(|x| (*x as f32).to_le_bytes()).collect();
let device = &context.device;
let make = |label, bytes: &[u8]| {
device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some(label),
contents: bytes,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
})
};
let raw = make("denoise fixture raw", &bytes);
let dummy = make("denoise unused geometry", &[0; 64]);
let mut task = Task::new(context.clone(), plane(), request(13), JobOptions::default(), CancelToken::default()).unwrap();
task.sample = 1;
let filter = Resources::new(&context, &task.uniform, [&dummy, &dummy, &dummy, &dummy, &dummy], &raw, bytes.len() as u64, false).unwrap();
let guide_bytes: Vec<u8> = guides.iter().flatten().flatten().flat_map(|x| (*x as f32).to_le_bytes()).collect();
context.queue.write_buffer(&filter._guides, 0, &guide_bytes);
let before = task.read_linear_buffer(&raw).unwrap();
filter.run_filter(&task, false).unwrap();
assert_eq!(before, task.read_linear_buffer(&raw).unwrap());
let actual = task.read_linear_buffer(filter.output()).unwrap();
let mut expected = input;
for step in [1, 2, 4] {
expected = reference(13, &expected, &guides, step);
}
for (a, b) in actual.iter().zip(&expected) {
for (x, y) in a.iter().zip(b) {
assert!((f64::from(*x) - *y).abs() < 2e-5, "{a:?} vs {b:?}");
}
}
}
#[test]
fn gpu_denoise_default_false_is_identical_and_true_preserves_raw() {
let Some(context) = context() else {
return;
};
let mut outputs = Vec::new();
let mut pngs = Vec::new();
for options in [
JobOptions { samples: 4, ..Default::default() },
JobOptions { samples: 4, denoise: false, ..Default::default() },
JobOptions { samples: 4, denoise: true, ..Default::default() },
] {
let mut task = Task::new(context.clone(), plane(), request(8), options, CancelToken::default()).unwrap();
assert_eq!(task.denoiser.is_some(), options.denoise);
while task.sample < 4 {
task.complete_sample().unwrap();
}
let raw = task.read_linear().unwrap();
if let Some(filter) = &task.denoiser {
filter.run(&task).unwrap();
assert_eq!(raw, task.read_linear().unwrap());
let filtered = task.read_linear_buffer(filter.output()).unwrap();
assert!(filtered.iter().all(|p| p.iter().all(|v| v.is_finite())));
let guides = read_guides(&context, &filter._guides);
assert_eq!(guides[0], [0.0; 4]);
let center = (4 * 8 + 4) * 3;
assert_eq!(guides[center], [0.5, 0.5, 0.5, 1.0]);
assert_eq!(guides[center + 1], [0.0, 0.0, 1.0, 16.0]);
assert!((guides[center + 2][0] - 0.2).abs() < 1e-6);
assert!((guides[center + 2][1] + 0.2).abs() < 1e-6);
assert!((guides[center + 2][3] - 0.4).abs() < 1e-6);
}
outputs.push(raw);
for _ in 0..100 {
if let TaskPoll::Complete(png) = task.step(4096).unwrap() {
pngs.push(png);
break;
}
}
}
assert_eq!(outputs[0], outputs[1]);
assert_eq!(outputs[0], outputs[2]);
assert_eq!(pngs.len(), 3);
assert_eq!(pngs[0], pngs[1]);
}
#[test]
fn gpu_denoise_preflight_reports_limits_without_changing_document() {
let Some(context) = context() else {
return;
};
let mut session = solidcraft_engine::Session::default();
session.set_render_job_host(Some(solidcraft_render::job::CpuHost::cooperative())).unwrap();
session.register_render_job_host(solidcraft_render::job::ImageHost::with_executor(Arc::new(Executor { context })).unwrap()).unwrap();
session.execute("solid.box", &serde_json::json!({"length":2,"width":2,"height":1})).unwrap();
let before = session.doc.to_json();
let mut params = serde_json::json!({"progressive":true,"denoise":true,"settings":{"width":8,"height":8}});
let reply = session.execute("render.preflight", ¶ms).unwrap();
assert_eq!(reply["options"]["denoise"], true);
assert_eq!(reply["denoising"]["passes"], 3);
assert_eq!(reply["denoising"]["raw_linear_accumulator_preserved"], true);
assert_eq!(before, session.doc.to_json());
params["progressive"] = serde_json::json!(false);
assert!(session.execute("render.preflight", ¶ms).is_err());
params["denoise"] = serde_json::json!(false);
let reply = session.execute("render.preflight", ¶ms).unwrap();
assert!(reply.get("denoising").is_none());
}