Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Render: reject excessive pixel work during preflight (#5088) (#5728)

Colin Faulkinghamd11d26859763
diff --git a/crates/engine/src/cmd/render/job_tests.rs b/crates/engine/src/cmd/render/job_tests.rs
index 0c1e307422..c2b42dd9de 100644
--- a/crates/engine/src/cmd/render/job_tests.rs
+++ b/crates/engine/src/cmd/render/job_tests.rs
@@ -480,6 +480,55 @@ fn compiled_out_raytrace_is_rejected_before_scene_capture() {
}
}
+#[test]
+fn preflight_and_start_reject_excessive_pixel_work_without_reserving_a_job() {
+ let (mut s, host) = session();
+ for _ in 0..8 {
+ s.execute("solid.box", &json!({"length":20,"width":20,"height":20,"corner":[-10,-10,-10]})).unwrap();
+ }
+ let mut camera = solidcraft_render::Camera { distance: 1.0, fov: 0.0, ..Default::default() };
+ camera.set_view(solidcraft_render::StandardView::Front);
+ let params = json!({"settings":{"width":1024,"height":1024,"camera":camera}});
+ let doc = s.doc.clone();
+ let before = (s.revision, s.evaluations, s.is_dirty(), s.undo.len(), s.redo.len());
+ for command in ["render.preflight", "render.start"] {
+ let error = s.execute(command, &params).unwrap_err().to_string();
+ assert!(error.contains("128000000 pixel tests"), "{error}");
+ assert_eq!(host.admitted_bytes(), 0);
+ }
+ assert!(Arc::ptr_eq(&doc, &s.doc));
+ assert_eq!(before, (s.revision, s.evaluations, s.is_dirty(), s.undo.len(), s.redo.len()));
+
+ #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
+ {
+ let raytrace_host = CpuHost::for_platform().unwrap();
+ s.set_render_job_host(Some(raytrace_host.clone())).unwrap();
+ let params = json!({"settings":{"width":1024,"height":1024,"camera":camera},
+ "integrator":"raytrace","transparent_background":false});
+ let preflight = s.execute("render.preflight", &params).unwrap();
+ assert_eq!(preflight["resolved"]["executor"], "cpu-raytrace");
+ assert!(preflight["admission"].get("projected_pixel_tests").is_none());
+ assert_eq!(raytrace_host.admitted_bytes(), 0);
+ let started = s.execute("render.start", &params).unwrap();
+ let id: JobId = serde_json::from_value(started["job"].clone()).unwrap();
+ s.execute("render.cancel", &json!({"job":id})).unwrap();
+ let status = s.render_job_handle(id).unwrap().wait_timeout(std::time::Duration::from_secs(10)).unwrap();
+ assert_eq!(status.progress.phase, solidcraft_render::job::Phase::Cancelled);
+ assert_eq!(raytrace_host.admitted_bytes(), 0);
+ assert!(Arc::ptr_eq(&doc, &s.doc));
+ assert_eq!(before, (s.revision, s.evaluations, s.is_dirty(), s.undo.len(), s.redo.len()));
+ s.set_render_job_host(Some(host.clone())).unwrap();
+ }
+
+ let params = json!({"settings":{"width":16,"height":16,"camera":camera}});
+ let preflight = s.execute("render.preflight", &params).unwrap();
+ assert!(preflight["admission"]["projected_pixel_tests"].as_u64().unwrap() > 0);
+ assert_eq!(host.admitted_bytes(), 0);
+ let id = s.execute("render.start", &params).unwrap()["job"].clone();
+ finish(&host);
+ assert_eq!(s.execute("render.status", &json!({"job":id})).unwrap()["progress"]["phase"], "completed");
+}
+
#[test]
fn identities_are_isolated_across_documents_scratch_and_new() {
let (mut a, host) = session();
diff --git a/crates/gpu/src/path/tests.rs b/crates/gpu/src/path/tests.rs
index cecbbc12fd..ed40cae2fb 100644
--- a/crates/gpu/src/path/tests.rs
+++ b/crates/gpu/src/path/tests.rs
@@ -591,6 +591,39 @@ fn admission_rejects_hostile_parameters_and_transparency() {
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
diff --git a/crates/render/src/job/host_tests.rs b/crates/render/src/job/host_tests.rs
index ed758ba5a7..62afa6298c 100644
--- a/crates/render/src/job/host_tests.rs
+++ b/crates/render/src/job/host_tests.rs
@@ -285,7 +285,7 @@ fn cancellation_while_encoding_cannot_publish_a_late_frame() {
}
#[test]
-fn malformed_preparation_fails_the_job_without_stopping_the_host() {
+fn malformed_geometry_is_rejected_without_stopping_the_host() {
let host = CpuHost::cooperative();
let scene = ProductScene {
bounds: Aabb3::EMPTY,
@@ -299,13 +299,9 @@ fn malformed_preparation_fails_the_job_without_stopping_the_host() {
faces: Vec::new(),
}],
};
- let broken = host.submit(id(1, 1), 1, scene, request()).unwrap();
- drain(&host);
- let status = broken.status().unwrap();
- assert_eq!(status.progress.phase, Phase::Failed);
- assert_eq!(status.error.unwrap().code, ErrorCode::InvalidScene);
- assert!(status.frame.is_none(), "a failed preparation path has no cached PNG identity");
- assert!(broken.frame().unwrap().is_none());
+ let error = host.submit(id(1, 1), 1, scene, request()).err().unwrap();
+ assert_eq!(error.code, ErrorCode::InvalidScene);
+ assert_eq!(host.admitted_bytes(), 0);
assert!(host.is_available());
let healthy = host.submit(id(1, 2), 1, empty(), request()).unwrap();
drain(&host);
@@ -538,6 +534,7 @@ impl ImageExecutor for DropProbe {
Ok(Admission {
triangles: 0,
face_appearances: 0,
+ projected_pixel_tests: None,
geometry_bytes: 0,
pixel_scratch_bytes: self.estimated,
preparation_bytes: 0,
@@ -780,6 +777,7 @@ fn registered_large_pool_is_explicit_finite_and_accounted() {
Ok(Admission {
triangles: 0,
face_appearances: 0,
+ projected_pixel_tests: None,
geometry_bytes: 0,
pixel_scratch_bytes: 0,
preparation_bytes: 0,
diff --git a/crates/render/src/job/image.rs b/crates/render/src/job/image.rs
index f297200566..de4a4f0db6 100644
--- a/crates/render/src/job/image.rs
+++ b/crates/render/src/job/image.rs
@@ -23,6 +23,9 @@ const SS: usize = 2;
pub struct Admission {
pub triangles: u64,
pub face_appearances: u64,
+ /// Supersampled raster work only; absent for ray tracing and registered executors.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub projected_pixel_tests: Option<u64>,
pub geometry_bytes: u64,
pub pixel_scratch_bytes: u64,
pub preparation_bytes: u64,
@@ -79,7 +82,9 @@ pub fn admit(scene: &ProductScene, request: &ImageRequest) -> Result<Admission>
}
pub(crate) fn admit_base(scene: &ProductScene, request: &ImageRequest) -> Result<Admission> {
- admit_raster(admit_source(scene, request, MAX_TRIANGLES)?)
+ let mut admission = admit_raster(admit_source(scene, request, MAX_TRIANGLES)?)?;
+ admission.projected_pixel_tests = Some(projected_pixel_tests(scene, request)?);
+ Ok(admission)
}
/// Common camera, dimension and source admission for registered executors, without any CPU
@@ -231,6 +236,7 @@ fn admit_source_with_limits(
admission: Admission {
triangles,
face_appearances: faces,
+ projected_pixel_tests: None,
geometry_bytes: geometry,
pixel_scratch_bytes: 0,
preparation_bytes: 0,
@@ -266,6 +272,137 @@ fn admit_raster(source: Source) -> Result<Admission> {
Ok(a)
}
+/// The same clipping, supersampling and bounds govern admission and raster work.
+struct Projection {
+ vp: Mat4,
+ back: Vec3,
+ target: Vec3,
+ sw: usize,
+ sh: usize,
+}
+
+impl Projection {
+ fn new(scene: &ProductScene, request: &ImageRequest) -> Result<Self> {
+ let (sw, sh) = (request.width as usize * SS, request.height as usize * SS);
+ let radius = scene.bounds.diagonal().max(10.0) + scene.bounds.center().dist(request.camera.target);
+ if !radius.is_finite() {
+ return Err(invalid("invalid product bounds"));
+ }
+ Ok(Self { vp: request.camera.view_proj(sw as f64 / sh as f64, radius), back: request.camera.back(), target: request.camera.target, sw, sh })
+ }
+
+ fn project(&self, body: &crate::ProductMesh, triangle: usize, look: Option<&FaceAppearance>) -> Result<Option<Triangle>> {
+ let mesh = &body.mesh;
+ let indices = mesh.triangles.get(triangle).ok_or_else(|| invalid("missing product triangle"))?;
+ let vertices = indices.map(|i| mesh.positions.get(i as usize).copied());
+ let normals = indices.map(|i| mesh.normals.get(i as usize).copied());
+ let ([Some(a), Some(b), Some(c)], [Some(na), Some(nb), Some(nc)]) = (vertices, normals) else {
+ return Err(invalid("invalid triangle index or missing normal"));
+ };
+ let world = [a, b, c];
+ let normals = [na, nb, nc];
+ if world.iter().chain(normals.iter()).any(|v| !v.is_finite()) {
+ return Err(invalid("non-finite product triangle"));
+ }
+ // Transmission is physical optical data, never a request to change CPU preview.
+ // Keep the existing scalar sorted-alpha shading for glass previews.
+ let (colour, opacity, surface) = look.map_or((body.color, body.opacity, body.surface.filter(|_| body.transmission.is_none())), |look| {
+ (look.color, look.opacity, look.surface.filter(|_| look.transmission.is_none()))
+ });
+ if surface.is_some() && opacity != 1.0 {
+ return Err(invalid("opaque PBR requires opacity 1"));
+ }
+ let normals = if surface.is_some() {
+ [crate::surface::unit_direction(na), crate::surface::unit_direction(nb), crate::surface::unit_direction(nc)]
+ .map(|n| n.map_err(|e| invalid(&e.to_string())))
+ } else {
+ [Ok(normals[0]), Ok(normals[1]), Ok(normals[2])]
+ };
+ let [na, nb, nc] = normals;
+ let normals = [na?, nb?, nc?];
+ if opacity <= 0.0 {
+ return Ok(None);
+ }
+ let clip = world.map(|p| self.vp.apply(p));
+ if clip.iter().flatten().any(|v| !v.is_finite()) {
+ return Err(invalid("non-finite product projection"));
+ }
+ if clip.iter().any(|p| p[3] <= 1e-9) {
+ return Ok(None);
+ }
+ let inv_w = clip.map(|p| 1.0 / p[3]);
+ let points = clip.map(|p| [(p[0] / p[3] + 1.0) * 0.5 * self.sw as f64, (1.0 - p[1] / p[3]) * 0.5 * self.sh as f64, p[2] / p[3]]);
+ if points.iter().flatten().any(|v| !v.is_finite()) || points.iter().any(|p| !(p[2] as f32).is_finite()) {
+ return Err(invalid("product projection exceeds pixel precision"));
+ }
+ let [a, b, c] = points;
+ let (x0, x1) = (a[0].min(b[0]).min(c[0]).floor().max(0.0), a[0].max(b[0]).max(c[0]).ceil().min(self.sw as f64 - 1.0));
+ let (y0, y1) = (a[1].min(b[1]).min(c[1]).floor().max(0.0), a[1].max(b[1]).max(c[1]).ceil().min(self.sh as f64 - 1.0));
+ let area = (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+ if !(x0 <= x1 && y0 <= y1) || area.abs() < 1e-12 {
+ return Ok(None);
+ }
+ if !area.is_finite() {
+ return Err(invalid("invalid projected area"));
+ }
+ let centre_depth = (world[0] / 3.0 + world[1] / 3.0 + world[2] / 3.0 - self.target).dot(self.back);
+ if !centre_depth.is_finite() {
+ return Err(invalid("invalid triangle depth"));
+ }
+ Ok(Some(Triangle {
+ points,
+ world,
+ normals,
+ inv_w,
+ colour: colour.map(decode),
+ opacity,
+ surface,
+ centre_depth,
+ area,
+ bounds: [x0 as usize, x1 as usize, y0 as usize, y1 as usize],
+ x: x0 as usize,
+ y: y0 as usize,
+ }))
+ }
+}
+
+fn add_pixel_tests(sum: &mut u64, triangle: &Triangle) -> Result<()> {
+ let [x0, x1, y0, y1] = triangle.bounds;
+ let tests = ((x1 - x0 + 1) as u64).checked_mul((y1 - y0 + 1) as u64).ok_or_else(|| limit("pixel work overflow"))?;
+ *sum = sum.checked_add(tests).ok_or_else(|| limit("pixel work overflow"))?;
+ if *sum > MAX_PIXEL_TESTS {
+ return Err(limit("projected product exceeds 128000000 pixel tests; reduce image dimensions or visible geometry"));
+ }
+ Ok(())
+}
+
+fn validate_face(face: &FaceAppearance) -> Result<()> {
+ if !face.opacity.is_finite() || !(0.0..=1.0).contains(&face.opacity) {
+ return Err(invalid("invalid face opacity"));
+ }
+ Ok(())
+}
+
+fn projected_pixel_tests(scene: &ProductScene, request: &ImageRequest) -> Result<u64> {
+ let projection = Projection::new(scene, request)?;
+ let mut tests = 0;
+ for body in &scene.meshes {
+ let mut looks = BTreeMap::new();
+ for face in &body.faces {
+ validate_face(face)?;
+ // Match the document and task policy: the last assignment wins.
+ looks.insert(face.face, face);
+ }
+ for index in 0..body.mesh.triangles.len() {
+ let look = body.mesh.tri_face.get(index).and_then(|face| looks.get(face)).copied();
+ if let Some(triangle) = projection.project(body, index, look)? {
+ add_pixel_tests(&mut tests, &triangle)?;
+ }
+ }
+ }
+ Ok(tests)
+}
+
fn reserve<T>(count: usize) -> Result<Vec<T>> {
let mut v = Vec::new();
v.try_reserve_exact(count).map_err(|_| JobError::new(ErrorCode::AllocationFailed, "could not reserve render work memory"))?;
@@ -326,10 +463,7 @@ pub struct ImageTask {
admission: Admission,
cancel: CancelToken,
stage: Stage,
- vp: Mat4,
- back: Vec3,
- sw: usize,
- sh: usize,
+ projection: Projection,
looks: Vec<BTreeMap<u32, FaceAppearance>>,
body: usize,
item: usize,
@@ -361,13 +495,8 @@ impl ImageTask {
return Err(JobError::new(ErrorCode::InvalidRequest, "raster task cannot execute a raytrace request"));
}
let admission = admit(&scene, &request)?;
- let (sw, sh) = (request.width as usize * SS, request.height as usize * SS);
- let radius = scene.bounds.diagonal().max(10.0) + scene.bounds.center().dist(request.camera.target);
- if !radius.is_finite() {
- return Err(invalid("invalid product bounds"));
- }
- let vp = request.camera.view_proj(sw as f64 / sh as f64, radius);
- let back = request.camera.back();
+ let projection = Projection::new(&scene, &request)?;
+ let (sw, sh) = (projection.sw, projection.sh);
let looks = reserve(scene.meshes.len())?;
let (opaque, glass, scratch) =
(reserve(admission.triangles as usize)?, reserve(admission.triangles as usize)?, reserve(admission.triangles as usize)?);
@@ -378,10 +507,7 @@ impl ImageTask {
admission,
cancel,
stage: Stage::Looks,
- vp,
- back,
- sw,
- sh,
+ projection,
looks,
body: 0,
item: 0,
@@ -417,7 +543,9 @@ impl ImageTask {
Stage::Clear | Stage::Opaque | Stage::Glass | Stage::Downsample => Progress {
phase: Phase::Running,
done: self.pixel_done,
- total: self.pixel_tests + (self.sw * self.sh) as u64 + u64::from(self.request.width) * u64::from(self.request.height),
+ total: self.pixel_tests
+ + (self.projection.sw * self.projection.sh) as u64
+ + u64::from(self.request.width) * u64::from(self.request.height),
},
Stage::Encode => Progress {
phase: Phase::Encoding,
@@ -466,9 +594,7 @@ impl ImageTask {
self.looks.push(BTreeMap::new());
}
if let Some(face) = body.faces.get(self.item) {
- if !face.opacity.is_finite() || !(0.0..=1.0).contains(&face.opacity) {
- return Err(invalid("invalid face opacity"));
- }
+ validate_face(face)?;
let looks = self.looks.get_mut(self.body).ok_or_else(|| invalid("missing body appearances"))?;
// Match the document policy: the last assignment of a face wins.
looks.insert(face.face, face.clone());
@@ -483,78 +609,9 @@ impl ImageTask {
fn project(&self, draw: Draw) -> Result<Option<Triangle>> {
let body = self.scene.meshes.get(draw.body as usize).ok_or_else(|| invalid("missing product body"))?;
- let mesh = &body.mesh;
- let indices = mesh.triangles.get(draw.triangle as usize).ok_or_else(|| invalid("missing product triangle"))?;
- let vertices = indices.map(|i| mesh.positions.get(i as usize).copied());
- let normals = indices.map(|i| mesh.normals.get(i as usize).copied());
- let ([Some(a), Some(b), Some(c)], [Some(na), Some(nb), Some(nc)]) = (vertices, normals) else {
- return Err(invalid("invalid triangle index or missing normal"));
- };
- let world = [a, b, c];
- let normals = [na, nb, nc];
- if world.iter().chain(normals.iter()).any(|v| !v.is_finite()) {
- return Err(invalid("non-finite product triangle"));
- }
- let look = self.looks.get(draw.body as usize).and_then(|looks| mesh.tri_face.get(draw.triangle as usize).and_then(|face| looks.get(face)));
- // Transmission is physical optical data, never a request to change CPU preview.
- // Keep the existing scalar sorted-alpha shading for glass previews.
- let (colour, opacity, surface) = look.map_or((body.color, body.opacity, body.surface.filter(|_| body.transmission.is_none())), |look| {
- (look.color, look.opacity, look.surface.filter(|_| look.transmission.is_none()))
- });
- if surface.is_some() && opacity != 1.0 {
- return Err(invalid("opaque PBR requires opacity 1"));
- }
- let normals = if surface.is_some() {
- [crate::surface::unit_direction(na), crate::surface::unit_direction(nb), crate::surface::unit_direction(nc)]
- .map(|n| n.map_err(|e| invalid(&e.to_string())))
- } else {
- [Ok(normals[0]), Ok(normals[1]), Ok(normals[2])]
- };
- let [na, nb, nc] = normals;
- let normals = [na?, nb?, nc?];
- if opacity <= 0.0 {
- return Ok(None);
- }
- let clip = world.map(|p| self.vp.apply(p));
- if clip.iter().flatten().any(|v| !v.is_finite()) {
- return Err(invalid("non-finite product projection"));
- }
- if clip.iter().any(|p| p[3] <= 1e-9) {
- return Ok(None);
- }
- let inv_w = clip.map(|p| 1.0 / p[3]);
- let points = clip.map(|p| [(p[0] / p[3] + 1.0) * 0.5 * self.sw as f64, (1.0 - p[1] / p[3]) * 0.5 * self.sh as f64, p[2] / p[3]]);
- if points.iter().flatten().any(|v| !v.is_finite()) || points.iter().any(|p| !(p[2] as f32).is_finite()) {
- return Err(invalid("product projection exceeds pixel precision"));
- }
- let [a, b, c] = points;
- let (x0, x1) = (a[0].min(b[0]).min(c[0]).floor().max(0.0), a[0].max(b[0]).max(c[0]).ceil().min(self.sw as f64 - 1.0));
- let (y0, y1) = (a[1].min(b[1]).min(c[1]).floor().max(0.0), a[1].max(b[1]).max(c[1]).ceil().min(self.sh as f64 - 1.0));
- let area = (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
- if !(x0 <= x1 && y0 <= y1) || area.abs() < 1e-12 {
- return Ok(None);
- }
- if !area.is_finite() {
- return Err(invalid("invalid projected area"));
- }
- let centre_depth = (world[0] / 3.0 + world[1] / 3.0 + world[2] / 3.0 - self.request.camera.target).dot(self.back);
- if !centre_depth.is_finite() {
- return Err(invalid("invalid triangle depth"));
- }
- Ok(Some(Triangle {
- points,
- world,
- normals,
- inv_w,
- colour: colour.map(decode),
- opacity,
- surface,
- centre_depth,
- area,
- bounds: [x0 as usize, x1 as usize, y0 as usize, y1 as usize],
- x: x0 as usize,
- y: y0 as usize,
- }))
+ let look =
+ self.looks.get(draw.body as usize).and_then(|looks| body.mesh.tri_face.get(draw.triangle as usize).and_then(|face| looks.get(face)));
+ self.projection.project(body, draw.triangle as usize, look)
}
fn prepare_step(&mut self) -> Result<()> {
@@ -571,12 +628,7 @@ impl ImageTask {
}
let mut draw = Draw { body: self.body as u32, triangle: self.item as u32, depth: 0.0 };
if let Some(triangle) = self.project(draw)? {
- let [x0, x1, y0, y1] = triangle.bounds;
- let tests = ((x1 - x0 + 1) as u64).checked_mul((y1 - y0 + 1) as u64).ok_or_else(|| limit("pixel work overflow"))?;
- self.pixel_tests = self.pixel_tests.checked_add(tests).ok_or_else(|| limit("pixel work overflow"))?;
- if self.pixel_tests > MAX_PIXEL_TESTS {
- return Err(limit("projected product exceeds 128000000 pixel tests"));
- }
+ add_pixel_tests(&mut self.pixel_tests, &triangle)?;
draw.depth = triangle.centre_depth;
if triangle.opacity >= 1.0 {
self.opaque.push(draw);
@@ -637,7 +689,7 @@ impl ImageTask {
}
fn clear_step(&mut self) {
- if self.pixels.len() >= self.sw * self.sh {
+ if self.pixels.len() >= self.projection.sw * self.projection.sh {
self.stage = Stage::Opaque;
self.draw = 0;
return;
@@ -664,7 +716,7 @@ impl ImageTask {
}
let triangle = self.triangle.as_mut().ok_or_else(|| invalid("missing raster triangle"))?;
let eye = (self.request.camera.fov > 0.0).then(|| self.request.camera.eye());
- raster_pixel(triangle, self.sw, self.back, eye, self.request.studio_weights, &mut self.pixels, &mut self.depth)?;
+ raster_pixel(triangle, self.projection.sw, self.projection.back, eye, self.request.studio_weights, &mut self.pixels, &mut self.depth)?;
triangle.x += 1;
if triangle.x > triangle.bounds[1] {
triangle.x = triangle.bounds[0];
@@ -699,7 +751,7 @@ impl ImageTask {
let (mut colour, mut alpha) = ([0.0; 3], 0.0);
for dy in 0..SS {
for dx in 0..SS {
- let p = self.pixels.get((y * SS + dy) * self.sw + x * SS + dx).ok_or_else(|| invalid("missing downsample pixel"))?;
+ let p = self.pixels.get((y * SS + dy) * self.projection.sw + x * SS + dx).ok_or_else(|| invalid("missing downsample pixel"))?;
let a = f64::from(p[3]) / 255.0;
for (sum, channel) in colour.iter_mut().zip(p.iter().take(3)) {
*sum += decode(*channel) * a;
diff --git a/crates/render/src/job/image_tests.rs b/crates/render/src/job/image_tests.rs
index def644a3b2..79e38310fe 100644
--- a/crates/render/src/job/image_tests.rs
+++ b/crates/render/src/job/image_tests.rs
@@ -167,12 +167,7 @@ fn invalid_sizes_indices_opacity_and_large_work_lists_fail_without_a_frame() {
} else {
body.faces.push(FaceAppearance { face: 0, color: [0; 3], opacity: f64::NAN, surface: None, transmission: None });
}
- let mut task = ImageTask::new(scene(vec![body]), request(), CancelToken::default()).unwrap();
- let error = loop {
- if let Err(error) = task.step(64) {
- break error;
- }
- };
+ let error = ImageTask::new(scene(vec![body]), request(), CancelToken::default()).err().unwrap();
assert_eq!(error.code, ErrorCode::InvalidScene);
}
let mut body = body;
@@ -202,3 +197,64 @@ fn registered_executor_geometry_admission_excludes_the_cpu_raster_estimate() {
// The CPU host itself keeps rejecting the source.
assert_eq!(admit(&source, &r).unwrap_err().code, ErrorCode::LimitExceeded);
}
+
+#[test]
+fn admission_rejects_projected_pixel_work_before_starting_a_job() {
+ let mut body = square("Overlapping glass", [100, 120, 140], 0.55, Vec3::ZERO);
+ let mesh = Arc::make_mut(&mut body.mesh);
+ mesh.triangles = vec![[0, 1, 2]; 1024];
+ mesh.tri_face = vec![0; 1024];
+ let scene = scene(vec![body]);
+ let request = ImageRequest { width: 512, height: 512, ..request() };
+ let error = admit(&scene, &request).expect_err("preflight must reject the same pixel-work limit as the rasterizer");
+ assert_eq!(error.code, ErrorCode::LimitExceeded);
+ assert!(error.message.contains("pixel tests"));
+ let request = ImageRequest { width: 64, height: 64, ..request };
+ let admission = admit(&scene, &request).unwrap();
+ assert!(admission.projected_pixel_tests.unwrap() > 0);
+ assert!(admission.projected_pixel_tests.unwrap() <= MAX_PIXEL_TESTS);
+ let png = finish(ImageTask::new(scene, request, CancelToken::default()).unwrap());
+ assert_eq!(image::load_from_memory(&png).unwrap().width(), 64);
+}
+
+#[test]
+fn pixel_work_admission_includes_the_limit_and_uses_clipped_sample_bounds() {
+ let mut body = square("Full viewport", [100; 3], 1.0, Vec3::ZERO);
+ let mesh = Arc::make_mut(&mut body.mesh);
+ // Each triangle's bounds cover all 200 * 200 supersampled pixels.
+ mesh.triangles = vec![[0, 1, 2]; 3200];
+ mesh.tri_face = vec![0; 3200];
+ let mut request = ImageRequest { width: 100, height: 100, ..request() };
+ request.camera.distance = 1.0;
+ request.camera.fov = 0.0;
+ let mut scene = scene(vec![body]);
+ assert_eq!(admit(&scene, &request).unwrap().projected_pixel_tests, Some(128_000_000));
+ let mut task = ImageTask::new(scene.clone(), request.clone(), CancelToken::default()).unwrap();
+ while task.stage != Stage::Clear {
+ task.step(1).unwrap();
+ }
+ assert_eq!(task.pixel_tests, 128_000_000);
+ Arc::make_mut(&mut scene.meshes[0].mesh).triangles.push([0, 1, 2]);
+ assert_eq!(admit(&scene, &request).unwrap_err().code, ErrorCode::LimitExceeded);
+ // Registered executors budget their own work, independently of the raster projection.
+ let geometry = admit_geometry(&scene, &request, MAX_TRIANGLES).unwrap();
+ assert_eq!(geometry.projected_pixel_tests, None);
+ assert!(serde_json::to_value(geometry).unwrap().get("projected_pixel_tests").is_none());
+}
+
+#[test]
+fn pixel_work_ignores_invisible_triangles_and_respects_the_last_face_override() {
+ let mut body = square("Hidden", [100; 3], 0.0, Vec3::ZERO);
+ let request = request();
+ assert_eq!(admit(&scene(vec![body.clone()]), &request).unwrap().projected_pixel_tests, Some(0));
+ body.faces.push(FaceAppearance { face: 0, color: [100; 3], opacity: 0.55, surface: None, transmission: None });
+ assert!(admit(&scene(vec![body.clone()]), &request).unwrap().projected_pixel_tests.unwrap() > 0);
+ body.faces.push(FaceAppearance { face: 0, color: [100; 3], opacity: 0.0, surface: None, transmission: None });
+ assert_eq!(admit(&scene(vec![body]), &request).unwrap().projected_pixel_tests, Some(0));
+
+ let offscreen = square("Offscreen", [100; 3], 1.0, Vec3::new(10_000.0, 0.0, 0.0));
+ assert_eq!(admit(&scene(vec![offscreen]), &request).unwrap().projected_pixel_tests, Some(0));
+ let mut degenerate = square("Degenerate", [100; 3], 1.0, Vec3::ZERO);
+ Arc::make_mut(&mut degenerate.mesh).triangles = vec![[0, 0, 0]];
+ assert_eq!(admit(&scene(vec![degenerate]), &request).unwrap().projected_pixel_tests, Some(0));
+}
diff --git a/docs/render-jobs.md b/docs/render-jobs.md
index 6d0438ef9e..785fab7cbd 100644
--- a/docs/render-jobs.md
+++ b/docs/render-jobs.md
@@ -71,12 +71,17 @@ additionally yields after four rows. The UI pumps 1024 units per frame. These ar
bounds, not hard real-time guarantees: allocation, codec compression and OS scheduling
still have platform-dependent latency.
-Admission caps output at 4096 per dimension and 4 million pixels; pixel scratch is
+CPU raster admission caps output at 4096 per dimension and 4 million pixels; pixel scratch is
estimated at 48 bytes per output pixel (2x supersampling). Other limits: 262144
triangles/face overrides/edge polylines, 128 MiB retained source geometry, 384 MiB total
estimated memory per job, 512 MiB shared host admission including retained PNGs, and
-128 million projected pixel tests. The projected-work limit is checked during bounded
-preparation and may fail an admitted job. Encoded PNG bytes have an additional
+128 million projected pixel tests. Preflight and Start check projected work using the
+same clipped, supersampled triangle bounds as the rasterizer, including face opacity
+overrides. Raster admission reports `projected_pixel_tests`; CPU raytracing and registered
+GPU executors omit this field and use their own work and memory budgets. Over-budget
+raster requests are rejected before a job is queued, with advice to reduce image
+dimensions or visible geometry.
+The worker retains its bounded preparation check. Encoded PNG bytes have an additional
`8 * output_pixels + 65536` cap. Allocator and codec internals are estimates, not an
operating-system memory quota. Limits fail with errors rather than allocating unbounded
buffers. Completed frames keep their memory reservation while bytes are retained.