SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Startup falls back from a Direct3D 12 that can't build the UI pipeline (#6648) (#6682)
raykholoc264c7a42a48
diff --git a/apps/solidcraft/src/main.rs b/apps/solidcraft/src/main.rsindex 8a4f795b10..6c8a10b715 100644--- a/apps/solidcraft/src/main.rs+++ b/apps/solidcraft/src/main.rs@@ -713,6 +713,12 @@ fn main() -> eframe::Result {if safe_mode {notes.push("Safe mode: default settings (yours are kept for the next normal start), no recovery offer, software rendering.".into());}+ let fallback_note = std::env::var(startup::FALLBACK_NOTE_ENV).ok().map(|s| s.chars().take(4096).collect::<String>());+ if let Some(note) = &fallback_note {+ log::warn!("{note}");+ eprintln!("SolidCraft: {note}");+ notes.push(note.clone());+ }let saved_samples = if safe_mode { None } else { msaa() };let wgpu_options = wgpu_options(cpu_renderer, if safe_mode { None } else { backend_preference() }.as_deref());let depth_bits = if !safe_mode && startup::float_depth_everywhere(&wgpu_options) { FLOAT_DEPTH_BITS } else { DEPTH_BITS };@@ -825,6 +831,7 @@ fn main() -> eframe::Result {}app.integrated_titlebar = cfg!(target_os = "macos");app.cpu_meshing = safe_mode;+ app.graphics_fallback = fallback_note.clone();if let Some(p) = cc.storage.and_then(|s| solidcraft_ui_egui::prefs::stored(|k| s.get_string(k))).filter(|_| !safe_mode) {app.load_prefs(&p);}@@ -957,7 +964,7 @@ fn main() -> eframe::Result {);control_server::remove_token_file();match result {- Err(e) if !created.load(std::sync::atomic::Ordering::SeqCst) => no_window(e, cpu_renderer, settings.as_deref()),+ Err(e) if !created.load(std::sync::atomic::Ordering::SeqCst) => no_window(e, cpu_renderer, started, settings.as_deref()),r => r,}}@@ -978,6 +985,9 @@ fn wgpu_options(cpu: bool, preference: Option<&str>) -> eframe::egui_wgpu::WgpuClet mut options = eframe::egui_wgpu::WgpuConfiguration::default();if let eframe::egui_wgpu::WgpuSetup::CreateNew(setup) = &mut options.wgpu_setup {let env_set = std::env::var(startup::WGPU_BACKEND_ENV).is_ok_and(|v| !v.trim().is_empty());+ // A retry applies only to this launch. WGPU_BACKEND always has priority.+ let retry = std::env::var(startup::RETRY_BACKEND_ENV).ok();+ let preference = if cpu { preference } else { retry.as_deref().or(preference) };if let Some(backends) = startup::choose_backends(cfg!(target_os = "windows"), env_set, cpu, preference, startup::has_hardware_adapter) {eprintln!("SolidCraft graphics: starting {backends:?}");setup.instance_descriptor.backends = backends;@@ -999,24 +1009,47 @@ fn wgpu_options(cpu: bool, preference: Option<&str>) -> eframe::egui_wgpu::WgpuCoptions}-/// The window never opened (no graphics adapter, a device that wouldn't start): once more on-/// the software renderer, else a message box saying what failed instead of a silent exit.-fn no_window(error: eframe::Error, tried_cpu: bool, settings: Option<&std::path::Path>) -> eframe::Result {+/// A failed renderer returns here before app creation. A fresh process avoids reusing winit's+/// event loop or a failed device; each retry advances through the APIs, then software once.+fn no_window(error: eframe::Error, tried_cpu: bool, failed: eframe::wgpu::Backends, settings: Option<&std::path::Path>) -> eframe::Result {log::error!("the window could not open: {error}");eprintln!("SolidCraft: the window could not open: {error}");- if !tried_cpu && let Ok(exe) = std::env::current_exe() {- eprintln!("SolidCraft: trying again with the software renderer ({}=cpu)", startup::RENDERER_ENV);- match std::process::Command::new(exe).args(std::env::args_os().skip(1)).env(startup::RENDERER_ENV, "cpu").status() {+ // This failure was handled, so neither the marker nor the journal should call it a crash.+ if let Some(dir) = settings {+ startup::started(dir);+ }+ solidcraft_engine::crash::end_session();+ let explicit = std::env::var(startup::WGPU_BACKEND_ENV).is_ok_and(|v| !v.trim().is_empty());+ if let Some(next) = startup::fallback_backend(cfg!(target_os = "windows"), explicit, tried_cpu, failed)+ && let Ok(exe) = std::env::current_exe()+ {+ let previous = std::env::var(startup::FALLBACK_NOTE_ENV).unwrap_or_default();+ let note = startup::fallback_note(&previous, failed, next, &error.to_string());+ log::warn!("{note}");+ eprintln!("SolidCraft: {note}");+ let mut command = std::process::Command::new(exe);+ command.args(std::env::args_os().skip(1)).env(startup::FALLBACK_NOTE_ENV, note);+ if next == "cpu" {+ command.env(startup::RENDERER_ENV, "cpu").env_remove(startup::RETRY_BACKEND_ENV);+ } else {+ command.env(startup::RETRY_BACKEND_ENV, next);+ }+ match command.status() {Ok(status) if status.success() => return Ok(()),- // The second try showed its own message.+ // The final try showed its own message.Ok(_) => return Err(error),- Err(e) => log::error!("could not start again with the software renderer: {e}"),+ Err(e) => log::error!("could not start again on {next}: {e}"),}}+ let message = if explicit {+ format!("SolidCraft could not open its window with WGPU_BACKEND.\n\n{error}\n\nChange or remove WGPU_BACKEND to try another graphics API.")+ } else {+ startup::no_window_message(&error.to_string(), settings)+ };let _ = rfd::MessageDialog::new().set_level(rfd::MessageLevel::Error).set_title("SolidCraft could not start")- .set_description(startup::no_window_message(&error.to_string(), settings))+ .set_description(message).set_buttons(rfd::MessageButtons::Ok).show();Err(error)diff --git a/apps/solidcraft/src/startup.rs b/apps/solidcraft/src/startup.rsindex df01438ad4..0a3c8cde8c 100644--- a/apps/solidcraft/src/startup.rs+++ b/apps/solidcraft/src/startup.rs@@ -8,8 +8,9 @@//! row the next launch starts in safe mode by itself.//! - **Safe mode** (`--safe-mode` or `SOLIDCRAFT_SAFE_MODE=1`): default settings (the saved ones//! are left untouched), no recovery offer, the software renderer and CPU meshing.-//! - **No usable graphics device**: one retry on the software renderer-//! (`SOLIDCRAFT_RENDERER=cpu`), then a message box saying what failed and what to try.+//! - **A renderer that cannot start**: on Windows, try the remaining graphics APIs in order,+//! then the software renderer (`SOLIDCRAFT_RENDERER=cpu`). An explicit `WGPU_BACKEND` fails+//! cleanly without switching. Exhausted retries show a message box with the error.use std::path::{Path, PathBuf};@@ -218,6 +219,34 @@ pub fn choose_backends(Some(WINDOWS_ORDER.into_iter().find(|b| has_hardware(*b)).unwrap_or(Backends::DX12))}+/// Internal, process-local retry choice; never written to the graphics preference.+pub const RETRY_BACKEND_ENV: &str = "SOLIDCRAFT_STARTUP_BACKEND";+/// Why this launch is using a fallback, carried to the new process for status and Preferences.+pub const FALLBACK_NOTE_ENV: &str = "SOLIDCRAFT_GRAPHICS_FALLBACK";++/// A handled startup failure tries each remaining Windows API once, then software rendering.+/// An explicit environment choice is final, including when software rendering was requested.+pub fn fallback_backend(windows: bool, explicit: bool, cpu: bool, failed: eframe::wgpu::Backends) -> Option<&'static str> {+ if explicit || cpu {+ return None;+ }+ if windows {+ let last = WINDOWS_ORDER.iter().rposition(|backend| failed.intersects(*backend));+ if let Some(next) = last.and_then(|i| WINDOWS_ORDER.get(i + 1)) {+ return Some(if *next == eframe::wgpu::Backends::VULKAN { "vulkan" } else { "gl" });+ }+ }+ Some("cpu")+}++/// Keep driver diagnostics on one bounded line, including across the finite retry chain.+pub fn fallback_note(previous: &str, failed: eframe::wgpu::Backends, next: &str, error: &str) -> String {+ let previous: String = previous.chars().take(2048).collect();+ let error: String = error.chars().take(1024).collect();+ let line = format!("{previous} Graphics fallback: {failed:?} failed ({error}); trying {next}.");+ line.split_whitespace().collect::<Vec<_>>().join(" ").chars().take(4096).collect()+}+/// The device feature for a 32-bit float depth buffer with a stencil (reversed depth, #1434).pub const FLOAT_DEPTH_STENCIL: eframe::wgpu::Features = eframe::wgpu::Features::DEPTH32FLOAT_STENCIL8;@@ -442,6 +471,42 @@ mod tests {assert_eq!(choose_backends(true, false, false, Some(""), probe(&[Backends::GL])), Some(Backends::GL));}+ #[test]+ fn failed_windows_backends_fall_back_in_order_and_stop_after_software() {+ use eframe::wgpu::Backends as B;+ assert_eq!(fallback_backend(true, false, false, B::DX12), Some("vulkan"));+ assert_eq!(fallback_backend(true, false, false, B::VULKAN), Some("gl"));+ assert_eq!(fallback_backend(true, false, false, B::GL), Some("cpu"));+ assert_eq!(fallback_backend(true, false, true, B::DX12), None);+ assert_eq!(fallback_backend(true, false, false, B::DX12 | B::VULKAN), Some("gl"));+ assert_eq!(fallback_backend(false, false, false, B::VULKAN), Some("cpu"));+ let note = fallback_note("", B::DX12, "vulkan", "egui_pipeline\n0x80070057");+ assert!(note.contains("egui_pipeline 0x80070057") && note.contains("vulkan") && !note.contains('\n'));+ let long = fallback_note(&"x".repeat(5000), B::VULKAN, "gl", &"y".repeat(5000));+ assert!(long.chars().count() <= 4096 && long.ends_with("trying gl."));+ }++ #[test]+ fn explicit_backend_failure_never_switches_api_or_retries_software() {+ use eframe::wgpu::Backends as B;+ for windows in [false, true] {+ for cpu in [false, true] {+ for backend in [B::DX12, B::VULKAN, B::GL, B::all()] {+ assert_eq!(fallback_backend(windows, true, cpu, backend), None);+ let mut probed = false;+ assert_eq!(+ choose_backends(windows, true, cpu, Some("vulkan"), |_| {+ probed = true;+ false+ }),+ None+ );+ assert!(!probed);+ }+ }+ }+ }+#[test]fn only_opengl_on_windows_gets_the_system_title_bar() {use eframe::wgpu::Backends;diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 7cf662b521..64f31a8bb4 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -494,6 +494,8 @@ pub struct SolveApp {pub msaa_supported: Vec<u32>,/// The startup check selected 1x; Graphics explains the workaround.pub msaa_compatibility: bool,+ /// Startup fallback diagnostic, also shown in Graphics preferences.+ pub graphics_fallback: Option<String>,/// Settings put back at start because they kept SolidCraft from starting, one line each,/// shown until dismissed (`prefs::show_reset_notice`).pub settings_reset: Vec<prefs::SettingReset>,@@ -644,6 +646,7 @@ impl SolveApp {stand_up_reason: false,msaa_supported: Vec::new(),msaa_compatibility: false,+ graphics_fallback: None,settings_reset: Vec::new(),big_operation: false,autosave_minutes: 5.0,diff --git a/crates/ui-egui/src/prefs/graphics.rs b/crates/ui-egui/src/prefs/graphics.rsindex 2b319bc935..bc19f89f62 100644--- a/crates/ui-egui/src/prefs/graphics.rs+++ b/crates/ui-egui/src/prefs/graphics.rs@@ -4,6 +4,9 @@ use super::*;pub(super) fn show(app: &mut SolveApp, ui: &mut egui::Ui) {let t = crate::theme::Tokens::get();ui_kit::settings_heading(ui, app.tr("prefs.graphics"), app.tr("prefs.graphics_note"));+ if let Some(note) = &app.graphics_fallback {+ ui_kit::text(ui, note, ui_kit::Text::Hint("graphics_fallback"));+ }if app.services.graphics_path.is_some() {ui_kit::settings_section(ui, "graphics_card", app.tr("prefs.graphics_card"), |ui| {let adapters = &app.services.graphics_adapters;diff --git a/docs/book/src/guide/troubleshooting.md b/docs/book/src/guide/troubleshooting.mdindex 5cdcd262b2..2a2fda414d 100644--- a/docs/book/src/guide/troubleshooting.md+++ b/docs/book/src/guide/troubleshooting.md@@ -68,7 +68,15 @@ SolidCraft needs Direct3D 12 or Vulkan on Windows, Metal on macOS, and Vulkan orLinux. Without a graphics driver it falls back to the system's software renderer (WARP onWindows, llvmpipe or lavapipe on Linux), which is slow but works. From 0.10.2, if no window canbe opened at all, SolidCraft tries the software renderer once and otherwise shows a message-saying what failed (earlier versions closed without a word). Things to try:+saying what failed (earlier versions closed without a word).++On Windows, if the graphics API cannot create the window's renderer, SolidCraft tries the+remaining APIs in order: Direct3D 12 → Vulkan → OpenGL, then software rendering. The status+message and **Preferences › Graphics** say which API failed and why. The saved graphics+preference stays unchanged. With an explicit `WGPU_BACKEND`, a failed start shows the error+and exits without switching; change or remove that variable to try another API.++Things to try:- Install the graphics driver from the GPU maker (Intel, AMD, NVIDIA) rather than Windows Update.- In a virtual machine, turn on 3D acceleration. Over Remote Desktop, try it on the machine itself.diff --git a/vendor/README.md b/vendor/README.mdindex a1655b908d..408a8a10d4 100644--- a/vendor/README.md+++ b/vendor/README.md@@ -318,3 +318,7 @@ SolidCraft changes:submits nothing (`DeviceLost::probe`), so a device the driver lost is found by thatsubmission rather than by the first queue write, which panicked inside wgpu-core(`PendingWrites::activate`, #4172).+- `src/lib.rs`: creation of the egui renderer uses validation, internal and out-of-memory+ error scopes, awaiting every result before returning it. A refused UI pipeline (D3D12+ `egui_pipeline` shader compilation, #6648) returns `WgpuError::CreateRendererError` through+ eframe so startup can retry another backend instead of invoking wgpu's panic handler.diff --git a/vendor/egui-wgpu/src/lib.rs b/vendor/egui-wgpu/src/lib.rsindex 089aeaeea6..0bba44e09b 100644--- a/vendor/egui-wgpu/src/lib.rs+++ b/vendor/egui-wgpu/src/lib.rs@@ -85,6 +85,10 @@ pub enum WgpuError {#[error(transparent)]RequestDeviceError(#[from] wgpu::RequestDeviceError),+ /// SolidCraft: pipeline validation must return to the startup retry.+ #[error("Could not create the egui renderer: {0}")]+ CreateRendererError(wgpu::Error),+#[error(transparent)]CreateSurfaceError(#[from] wgpu::CreateSurfaceError),@@ -414,7 +418,25 @@ impl RenderState {..options};startup_step(STEP_RENDERER, ""); // SolidCraft+ // SolidCraft: capture errors on the real surface/device, including driver shader+ // compilation failures, before wgpu's default uncaptured-error handler can panic.+ // Await every scope (also on WebGPU); an invalid renderer is never handed to eframe.+ let scopes = [+ wgpu::ErrorFilter::OutOfMemory,+ wgpu::ErrorFilter::Internal,+ wgpu::ErrorFilter::Validation,+ ]+ .map(|filter| device.push_error_scope(filter));let renderer = Renderer::new(&device, target_format, options);+ let mut failed = None;+ for scope in scopes.into_iter().rev() {+ if let Some(error) = scope.pop().await {+ failed.get_or_insert(error);+ }+ }+ if let Some(error) = failed {+ return Err(WgpuError::CreateRendererError(error));+ }// On wasm, depending on feature flags, wgpu objects may or may not implement sync.// It doesn't make sense to switch to Rc for that special usecase, so simply disable the lint.