SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
//! Native acceptance probe linked only to geom/render/gpu, not the CAD kernel or UI.
//! The Python runner verifies original source hashes and PNG output receipts.
#![forbid(unsafe_code)]
use solidcraft_geom::{Mesh, Vec3};
use solidcraft_render::job::textures::{BaseColorMode, PlanarFrame, RuntimeTextures, TextureBinding, TextureMap};
use solidcraft_render::job::{ImageHost, ImageRequest, Integrator, JobId, JobOptions, Phase, ToneMap};
use solidcraft_render::lighting::{HdrSource, environment::EnvironmentSource};
use solidcraft_render::texture_input::MapRole;
use solidcraft_render::{Camera, ProductMesh, ProductScene, surface::OpaqueSurface};
use std::{
error::Error,
fs,
io::Write,
path::{Path, PathBuf},
sync::Arc,
time::Duration,
};
struct Logger;
impl log::Log for Logger {
fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
metadata.level() <= log::Level::Info
}
fn log(&self, record: &log::Record<'_>) {
if self.enabled(record.metadata()) {
eprintln!("[{} {}] {}", record.level().as_str().to_lowercase(), record.target(), record.args());
}
}
fn flush(&self) {}
}
static LOGGER: Logger = Logger;
fn scene() -> Result<ProductScene, Box<dyn Error>> {
let mesh = Arc::new(Mesh {
positions: vec![Vec3::new(-50.0, -50.0, 0.0), Vec3::new(50.0, -50.0, 0.0), Vec3::new(50.0, 50.0, 0.0), Vec3::new(-50.0, 50.0, 0.0)],
normals: vec![Vec3::Z; 4],
triangles: vec![[0, 1, 2], [0, 2, 3]],
tri_face: vec![0, 0],
..Default::default()
});
Ok(ProductScene {
bounds: mesh.bounds(),
meshes: vec![ProductMesh {
name: "Original authored-surface coupon".into(),
mesh,
color: [220, 40, 20],
opacity: 1.0,
surface: Some(OpaqueSurface::new(Vec3::new(0.7, 0.02, 0.01), 0.0, 0.8, 1.5)?),
transmission: None,
faces: Vec::new(),
}],
})
}
fn map(root: &Path, name: &str, role: MapRole) -> Result<TextureMap, Box<dyn Error>> {
let file = root.join("assets/render/starter/materials/exports/SURF-001").join(format!("{name}.png"));
Ok(TextureMap::new(fs::read(file)?, role)?)
}
fn request(root: &Path) -> Result<ImageRequest, Box<dyn Error>> {
let hdr = HdrSource::new(fs::read(root.join("assets/render/starter/environments/exports/neutral-side-softbox.hdr"))?)?;
let environment = EnvironmentSource::from_hdr(hdr, std::f64::consts::PI, 1.0, false)?;
Ok(ImageRequest {
camera: Camera { distance: 220.0, ..Default::default() },
width: 320,
height: 240,
background: [236, 240, 245],
transparent_background: false,
integrator: Integrator::Raster,
raytrace: None,
environment: Some(Arc::new(environment)),
textures: None,
})
}
fn render(host: &ImageHost, root: &Path, out: &Path, label: &str, serial: u64, mode: BaseColorMode, scalars: bool) -> Result<String, Box<dyn Error>> {
let scene = scene()?;
let mut request = request(root)?;
let binding = TextureBinding {
body_index: 0,
body_name: "Original authored-surface coupon".into(),
frame: PlanarFrame { origin: [0.0; 3], u: [100.0, 0.0, 0.0], v: [0.0, 100.0, 0.0] },
normal_strength: 1.0,
base_color: Some(map(root, "base_color", MapRole::BaseColor)?),
normal: Some(map(root, "normal_open_gl", MapRole::NormalOpenGl)?),
roughness: if scalars { Some(map(root, "roughness", MapRole::Roughness)?) } else { None },
metallic: if scalars { Some(map(root, "metallic", MapRole::Metallic)?) } else { None },
base_color_mode: mode,
flip_v: true,
};
request.textures = Some(Arc::new(RuntimeTextures::new(vec![binding])?));
let options = JobOptions { samples: 64, max_depth: 6, seed: 82, tone_map: ToneMap::AcesFitted, ..Default::default() };
let admission = host.admit(&scene, &request, options)?;
let handle = host.submit_with_options(JobId { session: 20261022, serial, generation: 1 }, 1, scene, request, options)?;
let status = match handle.wait_timeout(Duration::from_secs(300)) {
Ok(status) => status,
Err(error) => {
let _ = handle.cancel();
return Err(error.into());
}
};
if status.progress.phase != Phase::Completed {
return Err(format!("GPU did not complete: {:?}", status.error).into());
}
let frame = handle.frame()?.ok_or("GPU completion has no retained frame")?;
if frame.info.executor.as_str() != "gpu-path" || (frame.info.width, frame.info.height) != (320, 240) {
return Err("wrong GPU executor or output dimensions".into());
}
let mut file = fs::OpenOptions::new().write(true).create_new(true).open(out.join(format!("{label}.png")))?;
file.write_all(frame.png())?;
file.sync_all()?;
println!(
"FRAME|{label}|{}|{}|{}|{}|{}|{}",
frame.info.png_sha256,
frame.info.png_bytes,
frame.info.width,
frame.info.height,
frame.info.executor.as_str(),
admission.estimated_total_bytes
);
let hash = frame.info.png_sha256.clone();
drop(frame);
drop(handle);
Ok(hash)
}
fn main() -> Result<(), Box<dyn Error>> {
log::set_logger(&LOGGER).map_err(|e| format!("logger: {e}"))?;
log::set_max_level(log::LevelFilter::Info);
let mut args = std::env::args_os().skip(1);
let root = args.next().map(PathBuf::from).ok_or("repository path required")?;
let out = args.next().map(PathBuf::from).ok_or("new output path required")?;
let host = solidcraft_gpu::path::host()?;
let full = render(&host, &root, &out, "authored-four-maps", 1, BaseColorMode::Replace, true)?;
let legacy = render(&host, &root, &out, "legacy-color-modulation", 2, BaseColorMode::Modulate, true)?;
let scalar_control = render(&host, &root, &out, "captured-scalar-control", 3, BaseColorMode::Replace, false)?;
if full == legacy || full == scalar_control {
return Err("authored surface and control renders must differ".into());
}
for _ in 0..100 {
if host.admitted_bytes() == 0 {
break;
}
std::thread::sleep(Duration::from_millis(10));
}
if host.admitted_bytes() != 0 {
return Err("GPU retained reservations were not released".into());
}
println!("POOL|0");
println!("STATUS|PASS");
Ok(())
}