SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Render hotfix: speed up mapped GPU path setup on lavapipe (#12664) (#12692)
selune684a4f4285b7
diff --git a/.config/nextest.toml b/.config/nextest.tomlindex b8ac317b65..671d8f81a5 100644--- a/.config/nextest.toml+++ b/.config/nextest.toml@@ -33,6 +33,12 @@ slow-timeout = { period = "60s" }[profile.ci.junit]path = "junit.xml"+# Bound the whole test process, including Vulkan host initialization and teardown.+# Cold runs can warm multiple pipelines before the first image starts rendering.+[[profile.ci.overrides]]+filter = "package(=solidcraft-ui-egui) & test(=render_workspace::tests::progressive_image_controls_route_to_the_registered_host)"+slow-timeout = { period = "60s", terminate-after = 20 }+# The action matrix sample runs its designs in parallel workers (ACTION_MATRIX_JOBS, set to match in# ci.yml). Its workers reserve that many of nextest's threads, so the cores are not oversubscribed# (a pi-case hole that takes 8 s alone went past the matrix's 90 s action limit when they were),diff --git a/assets/locales/pending/gpu-job-shader-wait.json b/assets/locales/pending/gpu-job-shader-wait.jsonnew file mode 100644index 0000000000..46a29b8224--- /dev/null+++ b/assets/locales/pending/gpu-job-shader-wait.json@@ -0,0 +1,10 @@+{+ "ar": {"render.gpu_job_shader_wait": "قد يستغرق تجهيز المظللات دقائق"},+ "de": {"render.gpu_job_shader_wait": "Shader-Vorbereitung kann Minuten dauern"},+ "en": {"render.gpu_job_shader_wait": "Shader setup can take minutes"},+ "he": {"render.gpu_job_shader_wait": "הכנת השיידרים עשויה להימשך כמה דקות"},+ "ja": {"render.gpu_job_shader_wait": "シェーダーの準備には数分かかることがあります"},+ "ko": {"render.gpu_job_shader_wait": "셰이더 준비에 몇 분이 걸릴 수 있습니다"},+ "vi": {"render.gpu_job_shader_wait": "Chuẩn bị shader có thể mất vài phút"},+ "zh": {"render.gpu_job_shader_wait": "准备着色器可能需要几分钟"}+}diff --git a/crates/gpu/src/path/path.wgsl b/crates/gpu/src/path/path.wgslindex 3e26e69430..12d30f868b 100644--- a/crates/gpu/src/path/path.wgsl+++ b/crates/gpu/src/path/path.wgsl@@ -1059,7 +1059,7 @@ fn direct_light(t: Triangle, position: vec3<f32>, physical: PrecisePoint, o: veclet emitter_limit=shadow_distance-select(u.lighting.x*2.0,0.0,punctual);if !studio || emitter_hit_precise(shadow_origin,shadow_origin_low,shadow_direction,shadow_minimum).distance>=emitter_limit {visibility = shadow_transmittance(shadow_origin,shadow_origin_low,shadow_direction,shadow_distance,shadow_minimum);- if studio && u.volume_min.w>0.0 {+ if !OPAQUE_SCENE && studio && u.volume_min.w>0.0 {var attenuation=volume_transmittance_precise(shadow_origin,shadow_origin_low,shadow_direction,shadow_distance);if punctual { attenuation=volume_transmittance_precise(physical.hi,physical.lo,sample.direction,physical_distance); }visibility.transmittance*=attenuation;@@ -1174,9 +1174,14 @@ fn sample_path_lane(pixel: u32, lane: u32) -> vec4<f32> {if !OPAQUE_SCENE && u.lighting.w>0.0 && bounce>0u && medium_count==0u && hit.triangle!=0xffffffffu {if !initialize_media_spectral(hit.triangle,d,&media,&medium_count,wavelength) {return medium_failure(radiance,coverage,pixel,bounce,4u);}}- if medium_count>0u && media[medium_count-1u].scatter.x>0.0 {+ // Surface hits and both kinds of scattering share the same ray and+ // emitter query. Keep one copy of its precise arithmetic in the shader.+ let emitter = emitter_hit_precise(o,o_low,d,ray_minimum);+ // Opaque jobs cannot enter a material medium or have a scene volume.+ // Specialize both walks out before the driver compiles the mapped shader.+ if !OPAQUE_SCENE && medium_count>0u && media[medium_count-1u].scatter.x>0.0 {let current=media[medium_count-1u];- let boundary=min(hit.distance,emitter_hit_precise(o,o_low,d,ray_minimum).distance);+ let boundary=min(hit.distance,emitter.distance);let travel=-log(1.0-random(&rng))/current.scatter.x;if travel<boundary {texture_path_length+=travel;@@ -1207,8 +1212,8 @@ fn sample_path_lane(pixel: u32, lane: u32) -> vec4<f32> {let segment=ray_segment_precise(o,o_low,previous_position,previous_position_low,d,boundary);previous_pdf*=exp(-current.scatter.x*length(segment));}- if u.volume_min.w>0.0 {- let emitter_distance=emitter_hit_precise(o,o_low,d,ray_minimum).distance;+ if !OPAQUE_SCENE && u.volume_min.w>0.0 {+ let emitter_distance=emitter.distance;var segment=vec2<f32>(0.0);if bounce==0u && u.eye.w<=0.5 {// The orthographic camera has no physical eye plane. Its fog@@ -1253,7 +1258,6 @@ fn sample_path_lane(pixel: u32, lane: u32) -> vec4<f32> {}}if u.environment.w > 0.0 {- let emitter = emitter_hit_precise(o,o_low,d,ray_minimum);if emitter.distance < hit.distance {let light = u.area_lights[emitter.index];let segment = ray_segment_precise(o,o_low,previous_position,previous_position_low,d,emitter.distance);diff --git a/crates/render/src/job/host.rs b/crates/render/src/job/host.rsindex 8a7a548939..245917e588 100644--- a/crates/render/src/job/host.rs+++ b/crates/render/src/job/host.rs@@ -513,6 +513,10 @@ impl JobHandle {pub fn id(&self) -> JobId {self.0.id}+ /// Time since submission, including queueing and preparation.+ pub fn elapsed(&self) -> std::time::Duration {+ self.0.started.elapsed()+ }/// True only after queued/running captures, tasks and their work reservations/// have been dropped. A terminal phase alone does not prove resource release./// Retained final/preview images and status-input leases remain owned by theirdiff --git a/crates/ui-egui/src/render_ui/mod.rs b/crates/ui-egui/src/render_ui/mod.rsindex 3a1ec0e42a..467c3965e0 100644--- a/crates/ui-egui/src/render_ui/mod.rs+++ b/crates/ui-egui/src/render_ui/mod.rs@@ -188,7 +188,9 @@ fn stage_tools(app: &mut SolveApp, ui: &mut egui::Ui) {}}+/// Draw render controls and status above the active model or image viewport.pub(crate) fn overlays(app: &mut SolveApp, ui: &mut egui::Ui) {+ crate::render_workspace::show_shader_preparation(app, ui.ctx());crate::shell::register_panel(app, "render:focus:exit", None, None);if focused(app) {dock_chip(app, ui, "render:focus:exit", "render.exit_focus", "view.render_focus", serde_json::json!({"on":false}));diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rsindex 2458cca11d..d39846ef0d 100644--- a/crates/ui-egui/src/render_workspace.rs+++ b/crates/ui-egui/src/render_workspace.rs@@ -3403,6 +3403,38 @@ pub(crate) fn apply_command(app: &mut SolveApp, id: &str, reply: &serde_json::VaOk(())}+/// GPU setup has no driver progress fraction. Keep its temporary window separate+/// from the render progress row and retire it as soon as preparation ends.+pub(crate) fn show_shader_preparation(app: &mut SolveApp, ctx: &egui::Context) -> bool {+ use solidcraft_engine::render::job::Phase;++ let Some(handle) = app.render_workspace.view.job.and_then(|job| app.session.render_job_handle(job).ok()) else {+ return false;+ };+ let Ok(status) = handle.status() else { return false };+ if status.progress.phase != Phase::Preparing || status.resolved.executor.as_str() != "gpu-path" {+ return false;+ }+ let mut cancel = false;+ crate::ui_kit::Window::new(egui::Id::unique("render_shader_preparation"), "", app.tr("render.image_preparing")).show_passive_body(ctx, |ui| {+ let warning = ui.label(app.tr("render.gpu_job_shader_wait"));+ crate::scenario::publish_rect("render:shader-preparation:warning", warning.rect);+ ui.horizontal(|ui| {+ let spinner = ui.spinner();+ crate::scenario::publish_rect("render:shader-preparation:spinner", spinner.rect);+ ui.label(mmss(handle.elapsed()));+ });+ let button = crate::ui_kit::button(ui, app.tr("cmd.render_cancel"), crate::ui_kit::Button::Normal);+ crate::scenario::publish_target("render:shader-preparation:cancel", button.rect);+ cancel = button.clicked();+ });+ if cancel && let Err(error) = app.run("render.cancel", json!({"job": handle.id()})) {+ app.set_status(error, true);+ }+ ctx.request_repaint_after(std::time::Duration::from_millis(100));+ true+}+/// `key` names the row's scenario handles (`ui_kit::progress_action`).pub(crate) fn progress_pill(app: &mut SolveApp, ui: &mut egui::Ui, key: &str) -> bool {if prepare::progress(app, ui) {@@ -3435,8 +3467,8 @@ pub(crate) fn progress_pill(app: &mut SolveApp, ui: &mut egui::Ui, key: &str) ->let fraction = (done as f64 / total as f64).clamp(0.0, 1.0) as f32;let phase_key = format!("render.image_{phase}");let name = app.render_workspace.view.job_shot.as_ref().unwrap_or(&app.render_workspace.view.name).clone();- let status = format!("· {} · {:.0}%", app.tr(&phase_key), fraction * 100.0);- let cancel = crate::ui_kit::progress_action(ui, key, &name, &status, fraction, app.tr_label("Cancel"));+ let message = format!("· {} · {:.0}%", app.tr(&phase_key), fraction * 100.0);+ let cancel = crate::ui_kit::progress_action(ui, key, &name, &message, fraction, app.tr_label("Cancel"));crate::scenario::publish_target("render:progress-cancel", cancel.rect);if cancel.clicked() {app.start("render.cancel");diff --git a/crates/ui-egui/src/render_workspace_tests.rs b/crates/ui-egui/src/render_workspace_tests.rsindex b90f31f2a3..ff7cee6e89 100644--- a/crates/ui-egui/src/render_workspace_tests.rs+++ b/crates/ui-egui/src/render_workspace_tests.rs@@ -1676,17 +1676,11 @@ fn render_preview_tab_surfaces_preserve_scene_backplates_and_viewport_overrides(#[cfg(not(target_arch = "wasm32"))]#[test]+/// Exercise the registered GPU host through the UI, including mapped output and glass.fn progressive_image_controls_route_to_the_registered_host() {- // GPU path tracing can hang on a software adapter (lavapipe); see issue #12664.- // Skipped there until that is fixed; it still runs on real GPUs.- let software = solidcraft_gpu::select::Policy::from_env()- .ok()- .and_then(solidcraft_gpu::select::pick)- .is_some_and(|(_, report)| report.tier == solidcraft_gpu::select::Tier::Software);- if software {- eprintln!("skipping progressive UI device test: software GPU adapter (#12664)");- return;- }+ use solidcraft_engine::render::job::Phase;+ use std::time::{Duration, Instant};+let host = solidcraft_gpu::select::Policy::from_env().and_then(|policy| solidcraft_gpu::select::pick(policy).ok_or_else(|| "no qualifying adapter".to_string())).and_then(|(adapter, _)| solidcraft_gpu::path::host_on_adapter(&adapter).map_err(|e| e.to_string()));@@ -1749,14 +1743,24 @@ fn progressive_image_controls_route_to_the_registered_host() {h.step(&json!({"click":{"handle":"render:stage:render.start"}})).unwrap();let job = h.app.render_workspace.view.job.unwrap();- let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);+ let handle = h.app.session.render_job_handle(job).unwrap();+ // The first mapped render compiles a separate pipeline on a cold Vulkan cache.+ // Allow the GPU host's setup budget, then keep the short deadline after preparation.+ let submitted = Instant::now();+ let queue_deadline = submitted + Duration::from_secs(30);+ let setup_deadline = submitted + Duration::from_secs(600);+ let mut render_deadline = None;while h.app.render_workspace.view.completed.is_none() {- assert!(- std::time::Instant::now() < deadline,- "progressive UI job did not complete: {:?}",- h.app.session.execute("render.status", &json!({"job":job}))- );- std::thread::sleep(std::time::Duration::from_millis(5));+ let status = handle.status().unwrap();+ let now = Instant::now();+ let deadline = match status.progress.phase {+ Phase::Queued => queue_deadline,+ Phase::Preparing => setup_deadline,+ Phase::Failed | Phase::Cancelled => panic!("progressive UI job ended: {status:?}"),+ _ => *render_deadline.get_or_insert(now + Duration::from_secs(30)),+ };+ assert!(now < deadline, "progressive UI job did not complete: {status:?}");+ std::thread::sleep(Duration::from_millis(5));h.frames(1);}let status = h.app.session.execute("render.status", &json!({"job":job})).unwrap();@@ -1787,8 +1791,8 @@ fn progressive_image_controls_route_to_the_registered_host() {assert_eq!(image_params(&h.app).unwrap(), checked);let started = h.app.run("render.start", checked).unwrap();let job = serde_json::from_value(started["job"].clone()).unwrap();- let status = h.app.session.render_job_handle(job).unwrap().wait_timeout(std::time::Duration::from_secs(30)).unwrap();- assert_eq!(status.progress.phase, solidcraft_engine::render::job::Phase::Completed, "{:?}", status.error);+ let status = h.app.session.render_job_handle(job).unwrap().wait_timeout(Duration::from_secs(30)).unwrap();+ assert_eq!(status.progress.phase, Phase::Completed, "{:?}", status.error);assert!(Arc::ptr_eq(&doc, &h.app.session.doc));assert_eq!(h.app.session.undo.len(), undo);assert!(!h.app.session.is_dirty());@@ -6975,9 +6979,12 @@ fn auto_opened_image_cancel_returns_to_model_and_preserves_previous_or_explicit_#[cfg(not(target_arch = "wasm32"))]#[test]-fn auto_opened_image_failure_returns_to_model_and_reports_the_job_error() {+/// Hold a GPU job in preparation to verify the window, shared keys and failure cleanup.+fn gpu_preparation_shows_shader_warning_then_reports_job_failure() {use solidcraft_engine::render::job;- struct Failed;+ use std::sync::{Mutex, mpsc};+ use std::time::Duration;+ struct Failed(mpsc::Sender<()>, Mutex<mpsc::Receiver<()>>);impl job::ImageExecutor for Failed {fn descriptor(&self) -> job::Result<ExecutorDescriptor> {let mut descriptor = job::CpuHost::cooperative().descriptor()?;@@ -6989,11 +6996,15 @@ fn auto_opened_image_failure_returns_to_model_and_reports_the_job_error() {job::admit(scene, request)}fn begin(&self, _: ProductScene, _: job::ImageRequest, _: job::JobOptions, _: job::CancelToken) -> job::Result<Box<dyn job::ImageWork>> {+ self.0.send(()).unwrap();+ let _ = self.1.lock().unwrap().recv_timeout(Duration::from_secs(10));Err(job::JobError::new(job::ErrorCode::Internal, "controlled image failure"))}}let mut h = output_viewer_fixture();- let host = job::ImageHost::with_executor(Arc::new(Failed)).unwrap();+ let (entered, preparing) = mpsc::channel();+ let (release, wait) = mpsc::channel();+ let host = job::ImageHost::with_executor(Arc::new(Failed(entered, Mutex::new(wait)))).unwrap();h.app.session.register_render_job_host(host.clone()).unwrap();h.app.render_workspace.path_host = PathHost::Ready(host);h.app.render_workspace.view.method = ImageMethod::GpuRaytrace;@@ -7001,7 +7012,28 @@ fn auto_opened_image_failure_returns_to_model_and_reports_the_job_error() {let job = h.app.render_workspace.view.job.unwrap();assert_eq!(h.app.render_workspace.view.auto_result_job.as_ref().map(|auto| auto.job), Some(job));let handle = h.app.session.render_job_handle(job).unwrap();- assert_eq!(handle.wait_timeout(std::time::Duration::from_secs(10)).unwrap().progress.phase, job::Phase::Failed);+ preparing.recv_timeout(Duration::from_secs(10)).unwrap();+ assert_eq!(handle.status().unwrap().progress.phase, job::Phase::Preparing);+ let keys = [egui::Key::Enter, egui::Key::Escape];+ let events = keys+ .into_iter()+ .map(|key| egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE })+ .collect();+ let _ = h.ctx.run_ui(egui::RawInput { events, ..Default::default() }, |ui| {+ assert!(show_shader_preparation(&mut h.app, ui.ctx()));+ for key in keys {+ assert!(ui.ctx().input_mut(|input| input.consume_key(egui::Modifiers::NONE, key)), "{key:?} must be available to other windows");+ }+ assert!(progress_pill(&mut h.app, ui, "render:progress"));+ });+ assert!(crate::scenario::rect_of("render:progress:name").is_some());+ assert!(crate::scenario::rect_of("dialog:progress:render:progress").is_some());+ for control in ["warning", "spinner", "cancel"] {+ assert!(crate::scenario::rect_of(&format!("render:shader-preparation:{control}")).is_some());+ }+ release.send(()).unwrap();+ assert_eq!(handle.wait_timeout(Duration::from_secs(10)).unwrap().progress.phase, job::Phase::Failed);+ assert!(!show_shader_preparation(&mut h.app, &h.ctx));cache_render_images(&mut h.app, &h.ctx);assert!(!h.app.render_workspace.view.result);assert!(h.app.render_workspace.view.auto_result_job.is_none());diff --git a/crates/ui-egui/src/ui_kit/panel.rs b/crates/ui-egui/src/ui_kit/panel.rsindex eaa91b8097..d5a226f50d 100644--- a/crates/ui-egui/src/ui_kit/panel.rs+++ b/crates/ui-egui/src/ui_kit/panel.rs@@ -1073,6 +1073,15 @@ impl<'a> Window<'a> {self.fields().actions("", "", None).show(ctx, true, body).0}+ /// Show a temporary status window with no header dismissal or dialog shortcuts.+ pub(crate) fn show_passive_body(mut self, ctx: &egui::Context, body: impl FnOnce(&mut Ui)) {+ self.closeable = false;+ // No footer handles either key, so leave both in the shared input queue.+ self.enter_submits = true;+ self.escape_closes = true;+ self.actions("", "", None).show(ctx, true, body);+ }+/// Draw shared header, content and optional footer, retaining the caller's IDs.pub(crate) fn show(self, ctx: &egui::Context, valid: bool, body: impl FnOnce(&mut Ui)) -> (bool, super::Action) {self.surface(ctx, false, |ui| self.content(ui, valid, body, |_| {}))