DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
Desktop: pick the graphics backend before the window exists; DirectX 12 on Windows (#297)
Jeremy Yao736acffe5fa8
diff --git a/Cargo.lock b/Cargo.lockindex 2f57f017f..d18de53d8 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -870,6 +870,7 @@ dependencies = ["log","muda","rfd",+ "serde","serde_json","winit","winresource",diff --git a/README.md b/README.mdindex 6884a15e5..5c7d4c1ad 100644--- a/README.md+++ b/README.md@@ -137,9 +137,24 @@ The file stops growing at 16 MiB. `--version` writes no file.| Variable | Effect ||---|---|| `RUST_LOG` | Log levels for standard error and the log file. Default: `info` for DesignCraft's own crates, `warn` for everything else. env_logger-style directives replace that, e.g. `RUST_LOG=debug`, `RUST_LOG=warn,designcraft_render=trace` or `RUST_LOG=info,wgpu_core=warn`; a directive ending in `*` covers every target starting with it (`designcraft*=debug`). |+| `WGPU_BACKEND` | The graphics backend that composites the window: `dx12`, `vulkan`, `gl` or `metal` (a comma-separated list lets wgpu choose among them). Default: DirectX 12 on Windows, Vulkan on Linux, Metal on macOS, with OpenGL as the fallback. Setting it also turns off the start-up fallback described below. |The logger is `apps/designcraft/src/logging.rs`; the web build logs to the browser console instead.+### Graphics backend++The canvas is rendered on the CPU; the GPU only composites the interface, through wgpu. A+graphics driver that faults takes the process down before any Rust code can catch it, so the+backend is chosen before the window exists, and a start that never showed a frame is remembered:+`gpu.json` in the settings directory records the backend being tried until the first frame has+been presented. A record left behind means that backend crashed (or the app was killed) at+start-up, so the next start tries the next one (DirectX 12, Vulkan, then OpenGL on Windows;+Vulkan, then OpenGL on Linux) and says so in the status bar. The list starts over once every+backend has failed, or with a new DesignCraft version; delete the file or set `WGPU_BACKEND` to+start afresh. Seen in the wild: on an AMD hybrid-graphics laptop (a Radeon RX 6800M beside an+integrated Radeon) the AMD Vulkan driver faulted at the first present, which is why DirectX 12 is+the Windows default. The code is `apps/designcraft/src/gpu.rs`.+### Web```shdiff --git a/ROADMAP.md b/ROADMAP.mdindex a73d64ea8..eb05508d1 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -37,6 +37,7 @@ DesignCraft aims at full Adobe InDesign parity — and to be better: faster, ope- Missing glyphs, as in InDesign: a character the applied font lacks is drawn as that font's missing-glyph box (its .notdef; a drawn box when the font's is empty), on screen and in PDF (as a path, so PDF/A and PDF/UA exports take it), and Preflight lists the characters by font. Preferences › Composition › Draw Missing Glyphs from Fallback Fonts (`document.preferences {glyphFallback}`, stored with the document) draws them from other fonts instead; it is off in new documents and IDML imports, on in documents saved before it existed. A missing font's substitute always uses fallback fonts.- Damage-region repaint: after an edit the canvas re-renders only the frames whose composed text (or the items that) changed and patches its texture — pixel-identical to a full render; typing in a frame repaints in under a millisecond instead of a full-viewport render (22 ms measured on the sample).- Crash recovery: unsaved documents are written to the recovery folder every 30 s and reopened (unsaved, remembering their files) after a crash; File › Revert and Save a Copy…; `file.recovery.*`, `file.revert`, `file.saveACopy`.+- Graphics backend chosen before the window exists (DirectX 12 on Windows, Vulkan on Linux, Metal on macOS, OpenGL as the fallback; `WGPU_BACKEND` overrides) with a start-up fallback: a backend whose start never showed a frame is skipped at the next start and the status bar says so (`gpu.json`). Found on an AMD hybrid-graphics laptop whose Vulkan driver faulted at the first present.- Edit › Paste Into (copied objects become a frame's content, clipped by it; rendered, PDF and IDML both ways — verified in InDesign 2026); Polygon Settings (sides, star inset; double-click the Polygon tool).- Color panel (fill/stroke proxy, CMYK/RGB/Lab sliders with channel ramps, tint slider for swatches, spectrum ramp, Add to Swatches) and Color Picker (double-click the proxy); mixed colours are unnamed (not listed in Swatches until added); `object.color`, `swatch.addToSwatches`, `swatch.addUnnamed`.- Place text files: Word (.docx: styles by name with their attributes, bold/italic/underline/size/font, footnotes, tables, tabs, breaks), RTF and plain text, into the insertion point, the selected frame or a new frame; autoflow adds pages and threaded frames until the text fits; Remove Styles option (`designcraft-textimport`).diff --git a/apps/designcraft/Cargo.toml b/apps/designcraft/Cargo.tomlindex eaacdd328..416b07406 100644--- a/apps/designcraft/Cargo.toml+++ b/apps/designcraft/Cargo.toml@@ -14,6 +14,7 @@ designcraft-engine = { workspace = true }designcraft-ui-egui = { workspace = true }eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit", "wayland", "x11", "links"] }egui = { workspace = true }+serde = { workspace = true }serde_json = { workspace = true }log = { workspace = true }diff --git a/apps/designcraft/src/gpu.rs b/apps/designcraft/src/gpu.rsnew file mode 100644index 000000000..e80f566b9--- /dev/null+++ b/apps/designcraft/src/gpu.rs@@ -0,0 +1,396 @@+//! Which wgpu backend draws the window, and the fallback when one of them crashes at start-up.+//!+//! The canvas is rendered on the CPU (`designcraft-render`); the GPU only composites the+//! interface, so every backend shows the same pixels and the one that never crashes is the right+//! one. wgpu's default backend set (`PRIMARY | GL`) enumerates Vulkan first, and on an AMD+//! hybrid-graphics laptop (a Radeon RX 6800M beside an integrated Radeon, two versions of+//! `amdvlk64.dll` loaded into the process) AMD's Vulkan driver faulted with an access violation+//! at the first swapchain present. A fault inside a driver can't be caught (the crash guard never+//! sees it), so the backend is chosen before the window exists: on Windows DirectX 12 first (the+//! backend browsers' WebGPU uses), then Vulkan, then OpenGL; on Linux Vulkan, then OpenGL; on+//! macOS Metal. `WGPU_BACKEND` — wgpu's own variable: `dx12`, `vulkan`, `gl`, `metal`, or a+//! comma-separated list — overrides the choice and turns the fallback off.+//!+//! The fallback: before the window is created, `gpu.json` in the settings directory records the+//! backend being tried; once a frame has been presented, that entry is cleared. An entry still+//! there at the next start means the previous start never got that far — the driver crashed, or+//! the app was killed meanwhile — so that backend joins `failed`, the next candidate is tried and+//! the status bar says so. When every candidate has failed the list starts over, and so does a+//! new DesignCraft version (drivers and wgpu move on). `DESIGNCRAFT_NO_PREFS` records nothing.++use std::path::{Path, PathBuf};++use eframe::wgpu;+use serde::{Deserialize, Serialize};++/// The record's file name inside the settings directory.+pub const FILE: &str = "gpu.json";++/// A graphics backend wgpu can draw the window with.+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]+#[serde(rename_all = "lowercase")]+pub enum Backend {+ Dx12,+ Vulkan,+ Metal,+ Gl,+}++impl Backend {+ /// The name the status bar and the log use.+ pub fn name(self) -> &'static str {+ match self {+ Backend::Dx12 => "DirectX 12",+ Backend::Vulkan => "Vulkan",+ Backend::Metal => "Metal",+ Backend::Gl => "OpenGL",+ }+ }++ /// wgpu's bit for this backend.+ pub fn bit(self) -> wgpu::Backends {+ match self {+ Backend::Dx12 => wgpu::Backends::DX12,+ Backend::Vulkan => wgpu::Backends::VULKAN,+ Backend::Metal => wgpu::Backends::METAL,+ Backend::Gl => wgpu::Backends::GL,+ }+ }++ /// The backend of the adapter wgpu picked; `None` for the web and no-op backends.+ pub fn of(backend: wgpu::Backend) -> Option<Backend> {+ match backend {+ wgpu::Backend::Dx12 => Some(Backend::Dx12),+ wgpu::Backend::Vulkan => Some(Backend::Vulkan),+ wgpu::Backend::Metal => Some(Backend::Metal),+ wgpu::Backend::Gl => Some(Backend::Gl),+ _ => None,+ }+ }+}++/// The backends to try on this platform, best first.+pub fn candidates() -> &'static [Backend] {+ if cfg!(windows) {+ &[Backend::Dx12, Backend::Vulkan, Backend::Gl]+ } else if cfg!(target_os = "macos") {+ &[Backend::Metal]+ } else {+ &[Backend::Vulkan, Backend::Gl]+ }+}++/// What `gpu.json` holds.+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]+pub struct Record {+ /// The DesignCraft version that wrote the record; another version starts afresh.+ #[serde(default)]+ pub version: String,+ /// The backend of a start that has not presented a frame yet.+ #[serde(default)]+ pub trying: Option<Backend>,+ /// Backends whose start never presented a frame.+ #[serde(default)]+ pub failed: Vec<Backend>,+}++/// The backend for a start, from [`choose`].+#[derive(Clone, Debug, PartialEq, Eq)]+pub struct Choice {+ pub backend: Backend,+ /// The record to write before the window is created.+ pub record: Record,+ /// The backend the previous start never finished with, when this start moves away from it.+ pub switched_from: Option<Backend>,+}++/// Pick the backend for this start from the candidates (best first) and the previous start's+/// record; `None` without candidates.+pub fn choose(candidates: &[Backend], previous: &Record, version: &str) -> Option<Choice> {+ let first = *candidates.first()?;+ let same_version = previous.version == version;+ let mut failed: Vec<Backend> = if same_version { previous.failed.clone() } else { Vec::new() };+ failed.retain(|b| candidates.contains(b));+ let unfinished = previous.trying.filter(|_| same_version);+ if let Some(b) = unfinished+ && !failed.contains(&b)+ {+ failed.push(b);+ }+ let backend = match candidates.iter().copied().find(|b| !failed.contains(b)) {+ Some(b) => b,+ // Every candidate has failed: start over rather than never starting.+ None => {+ failed.clear();+ first+ }+ };+ let switched_from = unfinished.filter(|b| *b != backend);+ Some(Choice { backend, record: Record { version: version.to_owned(), trying: Some(backend), failed }, switched_from })+}++/// The record in `path`; a missing or unreadable file is an empty record.+pub fn read(path: &Path) -> Record {+ std::fs::read(path).ok().and_then(|bytes| serde_json::from_slice(&bytes).ok()).unwrap_or_default()+}++/// Write `record` to `path` (creating the directory).+pub fn write(path: &Path, record: &Record) -> std::io::Result<()> {+ if let Some(dir) = path.parent() {+ std::fs::create_dir_all(dir)?;+ }+ let bytes = serde_json::to_vec_pretty(record).map_err(std::io::Error::other)?;+ std::fs::write(path, bytes)+}++/// A start in progress: the backend chosen for it and the record that says so until a frame has+/// been presented.+#[derive(Debug)]+pub struct Startup {+ pub backend: Backend,+ pub switched_from: Option<Backend>,+ /// `gpu.json`, when the record is persisted.+ path: Option<PathBuf>,+ record: Record,+}++impl Startup {+ /// Choose the backend for this start and record it in `path` (nothing is recorded without+ /// one). `None` when `WGPU_BACKEND` is set — wgpu follows it and the fallback is off — or the+ /// platform has no candidates.+ pub fn begin(path: Option<PathBuf>, version: &str) -> Option<Startup> {+ if wgpu::Backends::from_env().is_some_and(|b| !b.is_empty()) {+ log::info!("graphics: WGPU_BACKEND is set, wgpu picks the backend and the start-up fallback is off");+ return None;+ }+ Self::begin_unforced(path, version)+ }++ fn begin_unforced(path: Option<PathBuf>, version: &str) -> Option<Startup> {+ let previous = path.as_deref().map(read).unwrap_or_default();+ let choice = choose(candidates(), &previous, version)?;+ if let Some(p) = &path+ && let Err(e) = write(p, &choice.record)+ {+ log::warn!("graphics: {}: {e}", p.display());+ }+ match choice.switched_from {+ Some(from) => log::warn!(+ "graphics: the last start with {} never showed a frame; trying {} (failed so far: {:?})",+ from.name(),+ choice.backend.name(),+ choice.record.failed+ ),+ None => log::info!("graphics: {} (WGPU_BACKEND overrides)", choice.backend.name()),+ }+ Some(Startup { backend: choice.backend, switched_from: choice.switched_from, path, record: choice.record })+ }++ /// The backends wgpu may use: the chosen one, with OpenGL as the in-process fallback when it+ /// has no adapter (unless OpenGL itself has failed). Not on Windows: some OpenGL drivers+ /// (AMD's) crash while the instance is created (#167), before any fallback could help, so+ /// there OpenGL is only ever tried as its own candidate.+ pub fn backends(&self) -> wgpu::Backends {+ let mut backends = self.backend.bit();+ if !cfg!(windows) && !self.record.failed.contains(&Backend::Gl) {+ backends |= wgpu::Backends::GL;+ }+ backends+ }++ /// wgpu picked an adapter of `backend`: record that one, so a crash is blamed on the backend+ /// that is actually drawing.+ pub fn started_with(&mut self, backend: Backend) {+ if self.record.trying == Some(backend) {+ return;+ }+ self.backend = backend;+ self.record.trying = Some(backend);+ self.save();+ }++ /// A frame has been presented (or the app exited normally): this start did not crash.+ pub fn presented(&mut self) {+ if self.record.trying.take().is_some() {+ self.save();+ }+ }++ /// The status-bar line for a start that moved away from a backend that crashed.+ pub fn status_line(&self) -> Option<String> {+ let from = self.switched_from?;+ Some(format!(+ "Graphics: switched from {} to {} — the last start with {} never showed a frame (set WGPU_BACKEND to choose).",+ from.name(),+ self.backend.name(),+ from.name()+ ))+ }++ fn save(&self) {+ if let Some(p) = &self.path+ && let Err(e) = write(p, &self.record)+ {+ log::warn!("graphics: {}: {e}", p.display());+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use std::sync::atomic::{AtomicUsize, Ordering};++ const V: &str = "0.5.0";+ const WIN: &[Backend] = &[Backend::Dx12, Backend::Vulkan, Backend::Gl];++ fn temp_path(tag: &str) -> PathBuf {+ static N: AtomicUsize = AtomicUsize::new(0);+ let d = std::env::temp_dir().join(format!("designcraft-gpu-{tag}-{}-{}", std::process::id(), N.fetch_add(1, Ordering::Relaxed)));+ let _ = std::fs::remove_dir_all(&d);+ d.join(FILE)+ }++ fn record(trying: Option<Backend>, failed: &[Backend]) -> Record {+ Record { version: V.into(), trying, failed: failed.to_vec() }+ }++ #[test]+ fn every_platform_has_candidates_without_duplicates() {+ let c = candidates();+ assert!(!c.is_empty());+ for (i, b) in c.iter().enumerate() {+ assert!(!c[..i].contains(b), "{b:?} twice in {c:?}");+ }+ if cfg!(windows) {+ assert_eq!(c[0], Backend::Dx12, "DirectX 12 is the Windows default (AMD's Vulkan driver faulted at the first present)");+ assert!(!c.contains(&Backend::Metal));+ }+ if cfg!(target_os = "macos") {+ assert_eq!(c, &[Backend::Metal]);+ }+ }++ #[test]+ fn a_fresh_start_takes_the_first_candidate() {+ let c = choose(WIN, &Record::default(), V).unwrap();+ assert_eq!(c.backend, Backend::Dx12);+ assert_eq!(c.record, record(Some(Backend::Dx12), &[]));+ assert_eq!(c.switched_from, None);+ assert!(choose(&[], &Record::default(), V).is_none());+ }++ #[test]+ fn a_start_that_never_presented_moves_to_the_next_candidate() {+ let c = choose(WIN, &record(Some(Backend::Dx12), &[]), V).unwrap();+ assert_eq!(c.backend, Backend::Vulkan);+ assert_eq!(c.record, record(Some(Backend::Vulkan), &[Backend::Dx12]));+ assert_eq!(c.switched_from, Some(Backend::Dx12));++ let c = choose(WIN, &record(Some(Backend::Vulkan), &[Backend::Dx12]), V).unwrap();+ assert_eq!(c.backend, Backend::Gl);+ assert_eq!(c.record.failed, &[Backend::Dx12, Backend::Vulkan]);+ assert_eq!(c.switched_from, Some(Backend::Vulkan));+ }++ #[test]+ fn a_finished_start_keeps_the_failed_list_and_switches_silently() {+ // `trying` was cleared by a presented frame; the next start still avoids what failed.+ let c = choose(WIN, &record(None, &[Backend::Dx12]), V).unwrap();+ assert_eq!(c.backend, Backend::Vulkan);+ assert_eq!(c.record.failed, &[Backend::Dx12]);+ assert_eq!(c.switched_from, None);+ // The same backend failing again is listed once.+ let c = choose(WIN, &record(Some(Backend::Dx12), &[Backend::Dx12]), V).unwrap();+ assert_eq!(c.record.failed, &[Backend::Dx12]);+ }++ #[test]+ fn when_every_candidate_failed_the_list_starts_over() {+ let c = choose(WIN, &record(Some(Backend::Gl), &[Backend::Dx12, Backend::Vulkan]), V).unwrap();+ assert_eq!(c.backend, Backend::Dx12);+ assert_eq!(c.record.failed, &[]);+ assert_eq!(c.switched_from, Some(Backend::Gl));+ }++ #[test]+ fn another_version_or_platform_forgets_what_failed() {+ let old = Record { version: "0.4.0".into(), trying: Some(Backend::Dx12), failed: vec![Backend::Vulkan] };+ let c = choose(WIN, &old, V).unwrap();+ assert_eq!(c.backend, Backend::Dx12);+ assert_eq!(c.record, record(Some(Backend::Dx12), &[]));+ assert_eq!(c.switched_from, None);+ // A backend that is no candidate here (a record copied from another machine) is dropped.+ let c = choose(&[Backend::Vulkan, Backend::Gl], &record(None, &[Backend::Metal, Backend::Vulkan]), V).unwrap();+ assert_eq!(c.backend, Backend::Gl);+ assert_eq!(c.record.failed, &[Backend::Vulkan]);+ }++ #[test]+ fn the_record_round_trips_and_garbage_reads_as_empty() {+ let path = temp_path("roundtrip");+ assert_eq!(read(&path), Record::default());+ let r = record(Some(Backend::Vulkan), &[Backend::Dx12]);+ write(&path, &r).expect("write");+ assert_eq!(read(&path), r);+ let text = std::fs::read_to_string(&path).expect("read");+ assert!(text.contains("\"trying\": \"vulkan\"") && text.contains("\"dx12\""), "{text}");+ std::fs::write(&path, b"{not json").expect("garbage");+ assert_eq!(read(&path), Record::default());+ // Unknown fields and missing ones are tolerated.+ std::fs::write(&path, br#"{"failed":["gl"],"later":1}"#).expect("partial");+ assert_eq!(read(&path), Record { version: String::new(), trying: None, failed: vec![Backend::Gl] });+ let _ = std::fs::remove_dir_all(path.parent().expect("dir"));+ }++ #[test]+ fn a_start_records_its_backend_until_a_frame_is_presented() {+ let path = temp_path("startup");+ let mut s = Startup::begin_unforced(Some(path.clone()), V).expect("candidates");+ let first = candidates()[0];+ assert_eq!(s.backend, first);+ assert_eq!(read(&path).trying, Some(first));+ assert!(s.backends().contains(first.bit()));+ // OpenGL is the in-process fallback, except on Windows where it is only its own candidate.+ assert_eq!(s.backends().contains(wgpu::Backends::GL), !cfg!(windows) || first == Backend::Gl);+ assert_eq!(s.status_line(), None);++ // wgpu actually picked OpenGL (the chosen backend had no adapter): blame that one.+ s.started_with(Backend::Gl);+ assert_eq!(read(&path).trying, Some(Backend::Gl));+ s.presented();+ assert_eq!(read(&path), record(None, &[]));+ s.presented();+ assert_eq!(read(&path), record(None, &[]));++ // The next start after one that never presented: switches, says so, and leaves OpenGL+ // out of the set once it failed.+ write(&path, &record(Some(Backend::Gl), &[])).expect("write");+ let s = Startup::begin_unforced(Some(path.clone()), V).expect("candidates");+ if candidates().len() > 1 {+ assert_eq!(s.switched_from, Some(Backend::Gl));+ let line = s.status_line().expect("status");+ assert!(line.contains("OpenGL") && line.contains(s.backend.name()) && line.contains("WGPU_BACKEND"), "{line}");+ assert!(!s.backends().contains(wgpu::Backends::GL));+ } else {+ assert_eq!(s.switched_from, None);+ }+ let _ = std::fs::remove_dir_all(path.parent().expect("dir"));+ }++ #[test]+ fn without_a_path_nothing_is_written_and_a_bad_path_is_not_fatal() {+ let mut s = Startup::begin_unforced(None, V).expect("candidates");+ s.started_with(Backend::Gl);+ s.presented();+ // A file where the directory should be: every write fails, nothing panics.+ let blocked = temp_path("blocked");+ let dir = blocked.parent().expect("dir");+ std::fs::create_dir_all(dir.parent().expect("tmp")).expect("tmp");+ std::fs::write(dir, "a file where the directory should be").expect("block");+ let mut s = Startup::begin_unforced(Some(blocked.clone()), V).expect("candidates");+ s.started_with(Backend::Gl);+ s.presented();+ let _ = std::fs::remove_file(dir);+ }+}diff --git a/apps/designcraft/src/main.rs b/apps/designcraft/src/main.rsindex fa413e3ac..c30606232 100644--- a/apps/designcraft/src/main.rs+++ b/apps/designcraft/src/main.rs@@ -5,10 +5,14 @@//! `--control <port>` (or `DESIGNCRAFT_CONTROL_PORT`) starts a localhost JSON-lines control server://! `{"id":1,"method":"ui.inspect","params":{}}` → `{"id":1,"ok":true,"result":…}`.//! See `designcraft_ui_egui::control` for the methods.+//!+//! The graphics backend (DirectX 12, Vulkan, Metal or OpenGL) is chosen in `gpu` before the window+//! exists, with a fallback for a driver that crashes at start-up; `WGPU_BACKEND` overrides it.#![cfg_attr(all(target_os = "windows", not(debug_assertions)), windows_subsystem = "windows")]#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]mod control_server;+mod gpu;mod logging;#[cfg(target_os = "macos")]mod native_menu;@@ -16,33 +20,54 @@ mod native_menu;use designcraft_engine::Session;use designcraft_ui_egui::{DesignApp, Services};-struct App(DesignApp, #[cfg(target_os = "macos")] Option<native_menu::NativeMenu>);+struct App {+ app: DesignApp,+ #[cfg(target_os = "macos")]+ menu: Option<native_menu::NativeMenu>,+ /// The graphics start in progress (`gpu.json`) until a frame has been presented; see `gpu`.+ startup: Option<gpu::Startup>,+ /// Frames begun so far.+ frames: u32,+}impl eframe::App for App {fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {+ // The third call: two frames went through `ui`, so the first was presented and the driver+ // survived it (a fault at the first present is what the fallback in `gpu` is for).+ if self.frames >= 2+ && let Some(s) = self.startup.as_mut()+ {+ s.presented();+ self.startup = None;+ }+ self.frames = self.frames.saturating_add(1);#[cfg(target_os = "macos")]{- if self.1.is_none() && std::env::var_os("DESIGNCRAFT_NO_NATIVE_MENU").is_none() {- self.1 = Some(native_menu::NativeMenu::install(&mut self.0));+ if self.menu.is_none() && std::env::var_os("DESIGNCRAFT_NO_NATIVE_MENU").is_none() {+ self.menu = Some(native_menu::NativeMenu::install(&mut self.app));}- if let Some(m) = &mut self.1 {- m.poll(&mut self.0, ctx);+ if let Some(m) = &mut self.menu {+ m.poll(&mut self.app, ctx);}}- self.0.logic(ctx);+ self.app.logic(ctx);}fn raw_input_hook(&mut self, _ctx: &egui::Context, raw: &mut egui::RawInput) {- self.0.raw_input_hook(raw);+ self.app.raw_input_hook(raw);}fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {- self.0.ui(ui);+ self.app.ui(ui);}fn on_exit(&mut self) {- save_prefs(&self.0);+ // A normal exit before the third frame is not a crash.+ if let Some(s) = self.startup.as_mut() {+ s.presented();+ }+ save_prefs(&self.app);}}-/// The per-user settings directory: `ui.json`, `prefs.json` and `logs/` live here.+/// The per-user settings directory: `ui.json`, `prefs.json`, `gpu.json` and `logs/` live here.fn config_dir() -> Option<std::path::PathBuf> {if cfg!(target_os = "macos") {std::env::var_os("HOME").map(|h| std::path::PathBuf::from(h).join("Library/Application Support/DesignCraft"))@@ -56,12 +81,17 @@ fn config_dir() -> Option<std::path::PathBuf> {}}+/// `DESIGNCRAFT_NO_PREFS`: read and write nothing in the settings directory (tests, demos).+fn no_prefs() -> bool {+ std::env::var_os("DESIGNCRAFT_NO_PREFS").is_some()+}+fn prefs_path() -> Option<std::path::PathBuf> {config_dir().map(|b| b.join("ui.json"))}fn load_prefs(app: &mut DesignApp) {- if std::env::var_os("DESIGNCRAFT_NO_PREFS").is_some() {+ if no_prefs() {return;}if let Some(p) = prefs_path()@@ -80,7 +110,7 @@ fn load_prefs(app: &mut DesignApp) {}fn save_prefs(app: &DesignApp) {- if std::env::var_os("DESIGNCRAFT_NO_PREFS").is_some() {+ if no_prefs() {return;}if let Some(p) = prefs_path() {@@ -241,6 +271,14 @@ fn main() -> eframe::Result {if let Some(icon) = app_icon() {options.viewport = options.viewport.with_icon(icon);}+ // The graphics backend, decided before the window exists: a driver that faults takes the+ // process down before any Rust code can catch it (see `gpu`).+ let gpu = gpu::Startup::begin(if no_prefs() { None } else { config_dir().map(|d| d.join(gpu::FILE)) }, env!("CARGO_PKG_VERSION"));+ if let Some(s) = &gpu+ && let eframe::egui_wgpu::WgpuSetup::CreateNew(create) = &mut options.wgpu_options.wgpu_setup+ {+ create.instance_descriptor.backends = s.backends();+ }// winit has no file drag-and-drop on Wayland (only on X11), so dropping images from the file// manager showed a "no" cursor. Run through XWayland when it's there; DESIGNCRAFT_WAYLAND=1// keeps the native Wayland backend.@@ -255,11 +293,24 @@ fn main() -> eframe::Result {"DesignCraft",options,Box::new(move |cc| {+ let mut gpu = gpu;+ if let Some(rs) = &cc.wgpu_render_state {+ // What a bug report needs to know about the graphics driver.+ let info = rs.adapter.get_info();+ log::info!("graphics: {} on {:?} ({:?}; driver {} {})", info.name, info.backend, info.device_type, info.driver, info.driver_info);+ if let (Some(s), Some(backend)) = (gpu.as_mut(), gpu::Backend::of(info.backend)) {+ s.started_with(backend);+ }+ }let mut session = Session::new();// Crash recovery: reopen what a previous run left unsaved, then keep it current.session.recovery_dir = designcraft_engine::recovery::default_dir();let recovered = session.execute("file.recovery.open", &serde_json::json!({})).ok();let mut app = DesignApp::new(session, services());+ if let Some(line) = gpu.as_ref().and_then(gpu::Startup::status_line) {+ app.status(line);+ }+ // Recovered documents matter more than the graphics note; both are in the log.if let Some(n) = recovered.as_ref().and_then(|r| r["opened"].as_array()).map(Vec::len).filter(|n| *n > 0) {app.status(format!("Recovered {n} unsaved document{} from the last session.", if n == 1 { "" } else { "s" }));}@@ -277,11 +328,13 @@ fn main() -> eframe::Result {eprintln!("designcraft: {f}: {e}");}}- Ok(Box::new(App(+ Ok(Box::new(App {app,#[cfg(target_os = "macos")]- None,- )))+ menu: None,+ startup: gpu,+ frames: 0,+ }))}),)}