* Render lights: uniform light list, solo and mute, and the Light editor * Render lights: Lighting and Light editors to the approved design * Render lights: the scale-test frame carries the product light list * Restore the stable Render light mute target on the shared eye control * fix: validate the viewport BRDF probe with current shader dependencies * fix: compile legacy lighting controls only for tests * fix: scope the legacy lighting preset import to tests * fix: reuse the merged Add Light label and translations * test: enable the implemented Add Light radial action * fix: restrict the legacy CPU vector editor to tests * test: reveal Output before checking Lights browser focus * test: use the published Browser card rectangle for Output scrolling * test: reveal Output children before exercising editor navigation
189 lines
8.2 KiB
Rust
189 lines
8.2 KiB
Rust
//! Bounded native acceptance probe for explicit CPU profiles. This is not a speed
|
|
//! benchmark or an application/UI test. Writes only to a new caller-selected folder.
|
|
use serde_json::json;
|
|
use solidcraft_geom::{Mesh, Vec3};
|
|
use solidcraft_render::job::{CpuBudget, CpuHost, DirectionalLightOptions, ImageRequest, Integrator, JobId, JobOptions, Phase, RaytraceOptions};
|
|
use solidcraft_render::{Camera, ProductMesh, ProductScene, StandardView, surface::OpaqueSurface};
|
|
use std::{error::Error, fs, path::PathBuf, sync::Arc, time::Duration};
|
|
|
|
fn scene() -> Result<ProductScene, Box<dyn Error>> {
|
|
let mesh = Arc::new(Mesh {
|
|
positions: vec![Vec3::new(-20.0, -15.0, 0.0), Vec3::new(20.0, -15.0, 0.0), Vec3::new(20.0, 15.0, 0.0), Vec3::new(-20.0, 15.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 CPU admission plate".into(),
|
|
mesh,
|
|
color: [92, 150, 210],
|
|
opacity: 1.0,
|
|
surface: Some(OpaqueSurface::new(Vec3::new(0.1, 0.3, 0.6), 0.0, 0.5, 1.5)?),
|
|
transmission: None,
|
|
faces: Vec::new(),
|
|
}],
|
|
})
|
|
}
|
|
fn request(width: u32, height: u32, budget: CpuBudget) -> ImageRequest {
|
|
let mut camera = Camera { distance: 65.0, ..Default::default() };
|
|
camera.set_view(StandardView::Top);
|
|
ImageRequest {
|
|
studio_weights: None,
|
|
environment: None,
|
|
textures: None,
|
|
integrator: Integrator::Raytrace,
|
|
raytrace: Some(RaytraceOptions {
|
|
budget,
|
|
lights: Some(vec![DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 2.0 }]),
|
|
shadows: false,
|
|
..Default::default()
|
|
}),
|
|
camera,
|
|
width,
|
|
height,
|
|
background: [236, 240, 245],
|
|
transparent_background: false,
|
|
}
|
|
}
|
|
fn dense_scene() -> Result<ProductScene, Box<dyn Error>> {
|
|
let side = 500u32;
|
|
let vertices = (side + 1) * (side + 1);
|
|
let mut positions = Vec::new();
|
|
positions.try_reserve_exact(vertices as usize)?;
|
|
for y in 0..=side {
|
|
for x in 0..=side {
|
|
positions.push(Vec3::new(-20.0 + 40.0 * f64::from(x) / f64::from(side), -15.0 + 30.0 * f64::from(y) / f64::from(side), 0.0));
|
|
}
|
|
}
|
|
let mut triangles = Vec::new();
|
|
triangles.try_reserve_exact((2 * side * side) as usize)?;
|
|
for y in 0..side {
|
|
for x in 0..side {
|
|
let a = y * (side + 1) + x;
|
|
let b = a + 1;
|
|
let c = a + side + 2;
|
|
let d = a + side + 1;
|
|
triangles.push([a, b, c]);
|
|
triangles.push([a, c, d]);
|
|
}
|
|
}
|
|
let mesh =
|
|
Arc::new(Mesh { positions, normals: vec![Vec3::Z; vertices as usize], tri_face: vec![0; triangles.len()], triangles, ..Default::default() });
|
|
let mut result = scene()?;
|
|
result.bounds = mesh.bounds();
|
|
let body = result.meshes.first_mut().ok_or("missing fixture body")?;
|
|
body.mesh = mesh;
|
|
body.name = "Original 500000-triangle grid".into();
|
|
Ok(result)
|
|
}
|
|
fn body_scene() -> Result<ProductScene, Box<dyn Error>> {
|
|
let mut result = scene()?;
|
|
let template = result.meshes.first().cloned().ok_or("missing fixture body")?;
|
|
result.meshes.clear();
|
|
result.meshes.try_reserve_exact(20_000)?;
|
|
for y in 0..100 {
|
|
for x in 0..200 {
|
|
let (x, y) = (f64::from(x) - 99.5, f64::from(y) - 49.5);
|
|
let mesh = Arc::new(Mesh {
|
|
positions: vec![
|
|
Vec3::new(x - 0.4, y - 0.4, 0.0),
|
|
Vec3::new(x + 0.4, y - 0.4, 0.0),
|
|
Vec3::new(x + 0.4, y + 0.4, 0.0),
|
|
Vec3::new(x - 0.4, y + 0.4, 0.0),
|
|
],
|
|
normals: vec![Vec3::Z; 4],
|
|
triangles: vec![[0, 1, 2], [0, 2, 3]],
|
|
tri_face: vec![0, 0],
|
|
..Default::default()
|
|
});
|
|
let mut body = template.clone();
|
|
body.name = format!("Original tile {x} {y}");
|
|
body.mesh = mesh;
|
|
result.meshes.push(body);
|
|
}
|
|
}
|
|
result.bounds = solidcraft_geom::Aabb3 { min: Vec3::new(-100.0, -50.0, 0.0), max: Vec3::new(100.0, 50.0, 0.0) };
|
|
Ok(result)
|
|
}
|
|
|
|
fn main() -> Result<(), Box<dyn Error>> {
|
|
let out = std::env::args_os().nth(1).map(PathBuf::from).ok_or("usage: cpu_resource_smoke NEW_OUTPUT_DIRECTORY [4k|8k|dense|bodies]")?;
|
|
fs::create_dir(&out)?;
|
|
let host = CpuHost::for_platform()?;
|
|
let case = std::env::args().nth(2).unwrap_or_else(|| "4k".into());
|
|
let (width, height, budget, source) = match case.as_str() {
|
|
"4k" => (3840, 2160, CpuBudget::Studio, scene()?),
|
|
"8k" => (7680, 4320, CpuBudget::Workstation, scene()?),
|
|
"dense" => (256, 256, CpuBudget::Studio, dense_scene()?),
|
|
"bodies" => (512, 256, CpuBudget::Studio, body_scene()?),
|
|
_ => return Err("case must be 4k, 8k, dense or bodies".into()),
|
|
};
|
|
let compact = request(width, height, CpuBudget::Compact);
|
|
if host.admit(&source, &compact, JobOptions::default()).is_ok() {
|
|
return Err("legacy Compact incorrectly admitted a deliberately oversized request".into());
|
|
}
|
|
let mut studio = request(width, height, budget);
|
|
if case == "bodies" {
|
|
studio.camera.fit(&source.bounds);
|
|
}
|
|
let admission = host.admit(&source, &studio, JobOptions::default())?;
|
|
let id = JobId { session: 20261022, serial: 1, generation: 1 };
|
|
let handle = host.submit(id, 1, source.clone(), studio)?;
|
|
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!("CPU render failed: {:?}", status.error).into());
|
|
}
|
|
let frame = handle.frame()?.ok_or("completed CPU result has no frame")?;
|
|
let image = image::load_from_memory(frame.png())?.to_rgba8();
|
|
if image.dimensions() != (width, height) || !image.pixels().any(|pixel| pixel.0 != [236, 240, 245, 255]) {
|
|
return Err("image does not contain the original analytic fixture".into());
|
|
}
|
|
fs::write(out.join(format!("cpu-{case}.png")), frame.png())?;
|
|
let frame_info = serde_json::to_value(&frame.info)?;
|
|
drop(frame);
|
|
drop(handle);
|
|
// Native cleanup is observed through reservations; no capacity is claimed merely
|
|
// from a dimensions constant or a downscaled display texture.
|
|
for _ in 0..100 {
|
|
if host.admitted_bytes() == 0 {
|
|
break;
|
|
}
|
|
std::thread::sleep(Duration::from_millis(10));
|
|
}
|
|
if host.admitted_bytes() != 0 {
|
|
return Err("completed CPU frame reservation was not released".into());
|
|
}
|
|
|
|
// Synthetic cardinality probe only, not a heavy-assembly render benchmark.
|
|
let admission_scene = scene()?;
|
|
let template = admission_scene.meshes.first().ok_or("missing original plate")?;
|
|
let mut bodies = Vec::new();
|
|
bodies.try_reserve_exact(20_000)?;
|
|
for i in 0..20_000 {
|
|
let mut body = template.clone();
|
|
body.name = format!("Admission body {i}");
|
|
bodies.push(body);
|
|
}
|
|
let many = ProductScene { bounds: admission_scene.bounds, meshes: bodies };
|
|
if host.admit(&many, &request(16, 16, CpuBudget::Compact), JobOptions::default()).is_ok() {
|
|
return Err("Compact accepted too many bodies".into());
|
|
}
|
|
let bodies_admission = host.admit(&many, &request(16, 16, CpuBudget::Studio), JobOptions::default())?;
|
|
let record = json!({"status":"PASS","scope":"native CPU selected-case execution plus separate bounded synthetic body admission","case":case,"rendered_bodies":source.meshes.len(),"rendered_triangles":admission.triangles,
|
|
"not_a_performance_benchmark":true,"application_ui_tested":false,"frame":frame_info,
|
|
"image_admission":admission,"twenty_thousand_bodies_admission":bodies_admission,
|
|
"retained_pool_bytes_after_drop":host.admitted_bytes(),"compact_refused_both_explicit_large_requests":true});
|
|
fs::write(out.join("receipt.json"), serde_json::to_vec_pretty(&record)?)?;
|
|
println!("{}", serde_json::to_string_pretty(&record)?);
|
|
Ok(())
|
|
}
|