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.rsindex 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, ¶ms).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", ¶ms).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", ¶ms).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", ¶ms).unwrap();+ assert!(preflight["admission"]["projected_pixel_tests"].as_u64().unwrap() > 0);+ assert_eq!(host.admitted_bytes(), 0);+ let id = s.execute("render.start", ¶ms).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.rsindex 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 appearancesdiff --git a/crates/render/src/job/host_tests.rs b/crates/render/src/job/host_tests.rsindex 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.rsindex 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.rsindex 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.mdindex 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 arbounds, not hard real-time guarantees: allocation, codec compression and OS schedulingstill 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 isestimated at 48 bytes per output pixel (2x supersampling). Other limits: 262144triangles/face overrides/edge polylines, 128 MiB retained source geometry, 384 MiB totalestimated 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 anoperating-system memory quota. Limits fail with errors rather than allocating unboundedbuffers. Completed frames keep their memory reservation while bytes are retained.