diff --git a/.config/nextest.toml b/.config/nextest.toml index b8ac317b6..671d8f81a 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.json new file mode 100644 index 000000000..46a29b822 --- /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.wgsl index 3e26e6943..12d30f868 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, physical: PrecisePoint, o: vec let 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 { 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 vec4 { 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(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 { } } 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.rs index 8a7a54893..245917e58 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 their diff --git a/crates/ui-egui/src/render_ui/mod.rs b/crates/ui-egui/src/render_ui/mod.rs index 3a1ec0e42..467c3965e 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.rs index 2458cca11..d39846ef0 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::Va Ok(()) } +/// 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.rs index b90f31f2a..ff7cee6e8 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>); impl job::ImageExecutor for Failed { fn descriptor(&self) -> job::Result { 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> { + 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.rs index eaa91b809..d5a226f50 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, |_| {}))