Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

fix(ui): start with an anti-aliasing the graphics device can't do (#329)

Tobias Brecklee6a95615a091
diff --git a/apps/solvecraft/src/main.rs b/apps/solvecraft/src/main.rs
index a1a56dcb28..531f5212bf 100644
--- a/apps/solvecraft/src/main.rs
+++ b/apps/solvecraft/src/main.rs
@@ -200,6 +200,8 @@ fn main() -> eframe::Result {
if let Some(rs) = &cc.wgpu_render_state {
eprintln!("SolidCraft graphics: {:?}, MSAA {}x (requested {}x)", rs.adapter.get_info().backend, rs.msaa_samples, samples);
app.set_wgpu(rs, DEPTH_BITS, STENCIL_BITS, rs.msaa_samples);
+ // A saved anti-aliasing the device can't do: back to the default, with a notice.
+ solvecraft_ui_egui::prefs::check_msaa(&mut app, u32::from(samples));
}
if let Some(port) = control_port {
let rx = control_server::start(port, cc.egui_ctx.clone());
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 6e007d72f0..4e812b2173 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -239,6 +239,11 @@ pub struct SolveApp {
pub recoverable: Vec<solvecraft_engine::recovery::Entry>,
/// The bodies of a just-opened Y-up file, offered to be stood up (`stand_up`).
pub stand_up: Option<Vec<String>>,
+ /// The anti-aliasing sample counts the graphics device supports (empty without a GPU).
+ pub msaa_supported: Vec<u32>,
+ /// 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>,
/// The last command was a big operation: autosave after it.
pub big_operation: bool,
/// Autosave interval (minutes; 0 = only after big operations). A preference.
@@ -300,6 +305,8 @@ impl SolveApp {
autosave: None,
recoverable: Vec::new(),
stand_up: None,
+ msaa_supported: Vec::new(),
+ settings_reset: Vec::new(),
big_operation: false,
autosave_minutes: 5.0,
custom_titlebar: false,
@@ -335,6 +342,7 @@ impl SolveApp {
/// stencil buffer bits and MSAA sample count). Without it the viewport renders on the CPU.
pub fn set_wgpu(&mut self, rs: &egui_wgpu::RenderState, depth_bits: u8, stencil_bits: u8, samples: u32) {
self.viewport.gpu = Some(gpu::install(rs, depth_bits, stencil_bits, samples));
+ self.msaa_supported = rs.msaa_supported.clone();
let info = rs.adapter.get_info();
self.help.gpu = Some(format!("{} ({:?}, {:?})", info.name.trim(), info.backend, info.device_type));
}
@@ -412,7 +420,10 @@ impl SolveApp {
if let Some(t) = v.get("toolbar") {
self.toolbar_custom.load(t);
}
- if let Some(p) = v.get("preferences").and_then(|p| serde_json::from_value::<prefs::Prefs>(p.clone()).ok()) {
+ if let Some(mut p) = v.get("preferences").and_then(|p| serde_json::from_value::<prefs::Prefs>(p.clone()).ok()) {
+ if !prefs::MSAA.contains(&p.msaa) {
+ p.msaa = prefs::Prefs::default().msaa;
+ }
self.preferences = p;
}
// Saved before the theme was a preference: the Dark/Light flag says which.
@@ -1004,6 +1015,7 @@ impl SolveApp {
params_dialog::show(self, ui.ctx());
recovery_ui::show(self, ui.ctx());
stand_up::show(self, ui.ctx());
+ prefs::show_reset_notice(self, ui.ctx());
context_menu::show(self, ui.ctx());
delete::show(self, ui.ctx());
if self.custom_titlebar {
diff --git a/crates/ui-egui/src/locales/de.json b/crates/ui-egui/src/locales/de.json
index adbfc42bc8..53a5a4d7b6 100644
--- a/crates/ui-egui/src/locales/de.json
+++ b/crates/ui-egui/src/locales/de.json
@@ -11,6 +11,11 @@
"dialog.selected_count": "↖ {count} ausgewählt",
"document.save_changes": "Änderungen in {name} speichern?",
"document.unsaved_changes": "{name} enthält ungespeicherte Änderungen. Wenn Sie nicht speichern, gehen sie verloren.",
+ "settings.msaa_applies_on_restart": "Die Kantenglättung wird beim nächsten Start von SolidCraft übernommen",
+ "settings.msaa_reset": "{setting}: {requested}× wird von diesem Grafikgerät nicht unterstützt; jetzt {reset}× (unterstützt: {supported}).",
+ "settings.msaa_unsupported": "Von diesem Grafikgerät nicht unterstützt",
+ "settings.reset_intro": "Diese Einstellungen funktionieren auf diesem Computer nicht und würden den Start von SolidCraft verhindern. Sie wurden daher geändert:",
+ "settings.reset_title": "Einstellungen wurden geändert",
"sketch.degrees_of_freedom": "{count} Freiheitsgrade",
"sketch.draw_curves": "{linetype}-Kurven zeichnen",
"sketch.make_selection": "Auswahl als {linetype} markieren",
@@ -27,6 +32,7 @@
"ui.animate_view_changes": "Ansichtsänderungen animieren",
"ui.animation": "Animation",
"ui.animation_speed": "Animationsgeschwindigkeit",
+ "ui.anti_aliasing": "Kantenglättung",
"ui.apply": "Anwenden",
"ui.arc": "Kreisbogen",
"ui.assemble": "Zusammenbau",
@@ -199,6 +205,7 @@
"ui.one_side": "Einseitig",
"ui.open": "Öffnen",
"ui.open_ellipsis": "Öffnen...",
+ "ui.open_preferences": "Einstellungen öffnen",
"ui.open_recent": "Zuletzt verwendet",
"ui.operation": "Operation",
"ui.options": "Optionen",
diff --git a/crates/ui-egui/src/locales/en.json b/crates/ui-egui/src/locales/en.json
index b0feae8a60..c96a55374b 100644
--- a/crates/ui-egui/src/locales/en.json
+++ b/crates/ui-egui/src/locales/en.json
@@ -11,6 +11,11 @@
"dialog.selected_count": "↖ {count} selected",
"document.save_changes": "Save changes to {name}?",
"document.unsaved_changes": "{name} has unsaved changes. If you don't save, they are lost.",
+ "settings.msaa_applies_on_restart": "Anti-aliasing applies the next time SolidCraft starts",
+ "settings.msaa_reset": "{setting}: {requested}× isn't supported by this graphics device; it is now {reset}× (supported: {supported}).",
+ "settings.msaa_unsupported": "Not supported by this graphics device",
+ "settings.reset_intro": "These settings don't work on this computer and would keep SolidCraft from starting, so they were changed:",
+ "settings.reset_title": "Settings were changed",
"sketch.degrees_of_freedom": "{count} degrees of freedom",
"sketch.draw_curves": "Draw {linetype} curves",
"sketch.make_selection": "Make the selection {linetype}",
@@ -27,6 +32,7 @@
"ui.animate_view_changes": "Animate view changes",
"ui.animation": "Animation",
"ui.animation_speed": "Animation speed",
+ "ui.anti_aliasing": "Anti-aliasing",
"ui.apply": "Apply",
"ui.arc": "Arc",
"ui.assemble": "Assemble",
@@ -199,6 +205,7 @@
"ui.one_side": "One Side",
"ui.open": "Open",
"ui.open_ellipsis": "Open...",
+ "ui.open_preferences": "Open Preferences",
"ui.open_recent": "Open Recent",
"ui.operation": "Operation",
"ui.options": "Options",
diff --git a/crates/ui-egui/src/locales/ja.json b/crates/ui-egui/src/locales/ja.json
index 199385db03..169685d07f 100644
--- a/crates/ui-egui/src/locales/ja.json
+++ b/crates/ui-egui/src/locales/ja.json
@@ -11,6 +11,11 @@
"dialog.selected_count": "↖ {count} 個選択",
"document.save_changes": "{name} への変更を保存しますか?",
"document.unsaved_changes": "{name} には保存されていない変更があります。保存しない場合、変更内容は失われます。",
+ "settings.msaa_applies_on_restart": "アンチエイリアスは次回 SolidCraft を起動したときに適用されます",
+ "settings.msaa_reset": "{setting}: {requested}× はこのグラフィックスデバイスではサポートされていないため、{reset}× に変更しました(サポート: {supported})。",
+ "settings.msaa_unsupported": "このグラフィックスデバイスではサポートされていません",
+ "settings.reset_intro": "次の設定はこのコンピューターでは使用できず、SolidCraft が起動できなくなるため変更されました:",
+ "settings.reset_title": "設定が変更されました",
"sketch.degrees_of_freedom": "自由度 {count}",
"sketch.draw_curves": "{linetype}の曲線を描く",
"sketch.make_selection": "選択を{linetype}にする",
@@ -27,6 +32,7 @@
"ui.animate_view_changes": "視点変更をアニメーション表示",
"ui.animation": "アニメーション",
"ui.animation_speed": "アニメーション速度",
+ "ui.anti_aliasing": "アンチエイリアス",
"ui.apply": "適用",
"ui.arc": "円弧",
"ui.assemble": "アセンブリ",
@@ -199,6 +205,7 @@
"ui.one_side": "片側",
"ui.open": "開く",
"ui.open_ellipsis": "開く...",
+ "ui.open_preferences": "環境設定を開く",
"ui.open_recent": "最近使った項目を開く",
"ui.operation": "操作",
"ui.options": "オプション",
diff --git a/crates/ui-egui/src/locales/ko.json b/crates/ui-egui/src/locales/ko.json
index e3c1b94093..8175a12feb 100644
--- a/crates/ui-egui/src/locales/ko.json
+++ b/crates/ui-egui/src/locales/ko.json
@@ -11,6 +11,11 @@
"dialog.selected_count": "↖ {count}개 선택됨",
"document.save_changes": "{name}의 변경 사항을 저장하시겠습니까?",
"document.unsaved_changes": "{name}에 저장되지 않은 변경 사항이 있습니다. 저장하지 않으면 변경 사항이 사라집니다.",
+ "settings.msaa_applies_on_restart": "안티앨리어싱은 다음에 SolidCraft를 시작할 때 적용됩니다",
+ "settings.msaa_reset": "{setting}: {requested}×는 이 그래픽 장치에서 지원되지 않아 {reset}×로 변경했습니다(지원: {supported}).",
+ "settings.msaa_unsupported": "이 그래픽 장치에서 지원되지 않음",
+ "settings.reset_intro": "다음 설정은 이 컴퓨터에서 작동하지 않아 SolidCraft를 시작할 수 없게 하므로 변경되었습니다:",
+ "settings.reset_title": "설정이 변경되었습니다",
"sketch.degrees_of_freedom": "자유도 {count}개",
"sketch.draw_curves": "{linetype} 곡선 그리기",
"sketch.make_selection": "선택 항목을 {linetype}(으)로 변경",
@@ -27,6 +32,7 @@
"ui.animate_view_changes": "뷰 변경 애니메이션",
"ui.animation": "애니메이션",
"ui.animation_speed": "애니메이션 속도",
+ "ui.anti_aliasing": "안티앨리어싱",
"ui.apply": "적용",
"ui.arc": "호",
"ui.assemble": "조립",
@@ -199,6 +205,7 @@
"ui.one_side": "한 방향",
"ui.open": "열기",
"ui.open_ellipsis": "열기...",
+ "ui.open_preferences": "환경 설정 열기",
"ui.open_recent": "최근 항목 열기",
"ui.operation": "작업",
"ui.options": "옵션",
diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rs
index f811712dd6..a3504eb47c 100644
--- a/crates/ui-egui/src/prefs.rs
+++ b/crates/ui-egui/src/prefs.rs
@@ -158,6 +158,7 @@ pub fn nav_preset(id: &str) -> &'static NavPreset {
pub const PAGES: [&str; 7] = ["General", "Navigation", "Keyboard Shortcuts", "Design", "Graphics", "Sketch", "Selection"];
pub const PAGE_SHORTCUTS: usize = 2;
pub const PAGE_DESIGN: usize = 3;
+pub const PAGE_GRAPHICS: usize = 4;
pub const THEMES: [(&str, &str); 3] = [("dark", "Dark"), ("light", "Light"), ("system", "System")];
pub const MSAA: [u32; 4] = [1, 2, 4, 8];
@@ -332,7 +333,7 @@ fn defaults(app: &mut SolveApp, page: usize) {
p.up_axis = d.up_axis;
p.offer_stand_up = d.offer_stand_up;
}
- 4 => {
+ PAGE_GRAPHICS => {
let msaa = p.msaa != d.msaa;
p.msaa = d.msaa;
app.ui.visual_style = 0;
@@ -520,6 +521,77 @@ fn save_graphics(app: &SolveApp) {
}
}
+/// At start, with the graphics device known: the saved anti-aliasing (`requested` samples, as
+/// the host read it) is more than the device supports. The window would not have opened with it,
+/// so the renderer fell back; put the setting back to its default (or the largest supported
+/// count below it) and tell the user what changed.
+pub fn check_msaa(app: &mut SolveApp, requested: u32) {
+ let supported = &app.msaa_supported;
+ if requested <= 1 || supported.is_empty() || supported.contains(&requested) {
+ return;
+ }
+ let default = Prefs::default().msaa;
+ let reset = supported.iter().copied().filter(|&n| n <= default).max().unwrap_or(1);
+ let supported = supported.clone();
+ app.preferences.msaa = reset;
+ save_graphics(app);
+ app.settings_reset.push(SettingReset::Msaa { requested, reset, supported });
+}
+
+/// A setting put back at start because it would keep SolidCraft from starting.
+#[derive(Clone, Debug, PartialEq)]
+pub enum SettingReset {
+ /// Anti-aliasing samples the graphics device can't render with.
+ Msaa { requested: u32, reset: u32, supported: Vec<u32> },
+}
+
+impl SettingReset {
+ /// The line the notice shows, in the current interface language.
+ pub fn message(&self) -> String {
+ match self {
+ SettingReset::Msaa { requested, reset, supported } => {
+ let setting = format!("{} › {}", crate::i18n::tr("ui.graphics"), crate::i18n::tr("ui.anti_aliasing"));
+ let supported = supported.iter().map(|n| format!("{n}")).collect::<Vec<_>>().join("×, ") + "×";
+ crate::i18n::format(
+ "settings.msaa_reset",
+ &[("setting", &setting), ("requested", &requested.to_string()), ("reset", &reset.to_string()), ("supported", &supported)],
+ )
+ }
+ }
+ }
+}
+
+/// Settings put back at start (`SolveApp::settings_reset`), until dismissed.
+pub fn show_reset_notice(app: &mut SolveApp, ctx: &egui::Context) {
+ if app.settings_reset.is_empty() {
+ return;
+ }
+ let mut ok = false;
+ let mut prefs = false;
+ crate::frame::window(ctx, app.tr("settings.reset_title"), crate::frame::Width::Normal)
+ .id(egui::Id::new("sc_settings_reset"))
+ .collapsible(false)
+ .resizable(false)
+ .show(ctx, |ui| {
+ ui.label(app.tr("settings.reset_intro"));
+ ui.add_space(4.0);
+ for reset in &app.settings_reset {
+ ui.label(format!("• {}", reset.message()));
+ }
+ ui.add_space(6.0);
+ ui.horizontal(|ui| {
+ ok = ui.button(app.tr("ui.heading_ok")).clicked();
+ prefs = ui.button(app.tr("ui.open_preferences")).clicked();
+ });
+ });
+ if ok || prefs {
+ app.settings_reset.clear();
+ }
+ if prefs {
+ open_at(app, PAGE_GRAPHICS);
+ }
+}
+
pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
// File › Keyboard Shortcuts and Help › Keyboard Shortcuts open this dialog at that page.
if app.keymap.open {
@@ -646,7 +718,6 @@ const PREFS_NAV_W: f32 = 128.0;
/// One page of the dialog.
fn page(app: &mut SolveApp, ui: &mut egui::Ui, t: &Tokens) {
- let _language = crate::i18n::scope(&app.preferences.language);
let note = |ui: &mut egui::Ui, s: &str| {
ui.label("");
// Descriptions wrap within the page instead of widening it.
@@ -801,14 +872,18 @@ fn page(app: &mut SolveApp, ui: &mut egui::Ui, t: &Tokens) {
ui.label("Perspective view");
ui.checkbox(&mut app.ui.perspective, "");
ui.end_row();
- ui.label("Anti-aliasing");
+ ui.label(app.tr("ui.anti_aliasing"));
egui::ComboBox::from_id_salt("pref_msaa").selected_text(format!("{}×", app.preferences.msaa)).show_ui(ui, |ui| {
for m in MSAA {
- ui.selectable_value(&mut app.preferences.msaa, m, format!("{m}×"));
+ // Counts the graphics device can't do would keep the window from opening.
+ let ok = app.msaa_supported.is_empty() || app.msaa_supported.contains(&m);
+ ui.add_enabled_ui(ok, |ui| ui.selectable_value(&mut app.preferences.msaa, m, format!("{m}×")))
+ .inner
+ .on_disabled_hover_text(app.tr("settings.msaa_unsupported"));
}
});
ui.end_row();
- note(ui, "Anti-aliasing applies the next time SolidCraft starts");
+ note(ui, app.tr("settings.msaa_applies_on_restart"));
ui.label("Renderer");
ui.label(match (&app.viewport.gpu, &app.help.gpu) {
(Some(_), Some(g)) => format!("GPU: {g}"),
@@ -888,6 +963,9 @@ pub fn set(app: &mut SolveApp, p: &serde_json::Value) -> Result<serde_json::Valu
if !NAV_PRESETS.iter().any(|p| p.id == new.nav) || !MSAA.contains(&new.msaa) {
return Err("`nav` must be fusion, solidworks, inventor, alias, tinkercad or openscad and `msaa` 1, 2, 4 or 8".into());
}
+ if new.msaa != app.preferences.msaa && !app.msaa_supported.is_empty() && !app.msaa_supported.contains(&new.msaa) {
+ return Err(format!("this graphics device doesn't support `msaa` {}; it supports {:?}", new.msaa, app.msaa_supported));
+ }
if !THEMES.iter().any(|(id, _)| *id == new.theme) || !["z", "y"].contains(&new.up_axis.as_str()) {
return Err("`theme` must be dark, light or system and `up_axis` z or y".into());
}
@@ -916,6 +994,59 @@ pub fn set(app: &mut SolveApp, p: &serde_json::Value) -> Result<serde_json::Valu
mod tests {
use super::*;
+ #[test]
+ fn unsupported_saved_msaa_is_reset_to_the_default_with_a_notice() {
+ let dir = std::env::temp_dir().join(format!("sc_msaa_reset_{}", std::process::id()));
+ let _ = std::fs::create_dir_all(&dir);
+ let path = dir.join("graphics.json");
+ let services = crate::Services { graphics_path: Some(path.to_string_lossy().to_string()), ..Default::default() };
+ let mut app = SolveApp::new(solvecraft_engine::Session::default(), services);
+ // WebGPU's guarantee for the surface format: 8x saved, the device can only do 1x and 4x.
+ app.msaa_supported = vec![1, 4];
+ app.preferences.msaa = 8;
+ check_msaa(&mut app, 8);
+ assert_eq!(app.preferences.msaa, 4);
+ let saved: serde_json::Value = serde_json::from_str(&std::fs::read_to_string(&path).unwrap_or_default()).unwrap_or_default();
+ assert_eq!(saved["msaa"], 4);
+ assert_eq!(app.settings_reset, [SettingReset::Msaa { requested: 8, reset: 4, supported: vec![1, 4] }]);
+ assert_eq!(
+ app.settings_reset[0].message(),
+ "Graphics › Anti-aliasing: 8× isn't supported by this graphics device; it is now 4× (supported: 1×, 4×)."
+ );
+ {
+ let _de = crate::i18n::scope("de");
+ assert_eq!(
+ app.settings_reset[0].message(),
+ "Grafik › Kantenglättung: 8× wird von diesem Grafikgerät nicht unterstützt; jetzt 4× (unterstützt: 1×, 4×)."
+ );
+ }
+ // Below the default when the device can't do that either.
+ app.settings_reset.clear();
+ app.msaa_supported = vec![1, 2];
+ check_msaa(&mut app, 8);
+ assert_eq!(app.preferences.msaa, 2);
+ // Supported, off, or no GPU: nothing changes (OpenGL's 1x policy isn't a reset either).
+ for (supported, requested) in [(vec![1, 2, 4, 8], 8), (vec![1, 4], 1), (vec![], 8), (vec![1, 4], 4)] {
+ app.settings_reset.clear();
+ app.preferences.msaa = requested;
+ app.msaa_supported = supported;
+ check_msaa(&mut app, requested);
+ assert!(app.settings_reset.is_empty());
+ assert_eq!(app.preferences.msaa, requested);
+ }
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+
+ #[test]
+ fn control_channel_rejects_msaa_the_device_cannot_do_and_bad_saved_msaa_loads_as_default() {
+ let mut app = SolveApp::new(solvecraft_engine::Session::default(), crate::Services::default());
+ app.msaa_supported = vec![1, 4];
+ assert!(set(&mut app, &serde_json::json!({ "msaa": 8 })).is_err());
+ assert!(set(&mut app, &serde_json::json!({ "msaa": 1 })).is_ok());
+ app.load_prefs(&serde_json::json!({ "preferences": { "msaa": 16 } }).to_string());
+ assert_eq!(app.preferences.msaa, Prefs::default().msaa);
+ }
+
#[test]
fn length_fields_read_bare_numbers_in_design_units_and_honour_explicit_units() {
let inch = unit_scale("in").0;
diff --git a/vendor/README.md b/vendor/README.md
index e0ec2d0b17..5808b0e492 100644
--- a/vendor/README.md
+++ b/vendor/README.md
@@ -87,3 +87,9 @@ SolidCraft changes:
exposing the effective sample count so host paint callbacks can match it.
- `src/winit.rs`: use that same effective count for depth and resolve attachments.
- Other backends retain requested MSAA, without another adapter or device probe.
+- `src/lib.rs`: clamp MSAA to the largest sample count the device supports for the surface and
+ depth formats (`supported_msaa_samples`, `RenderState::msaa_supported`): a saved 8x on a
+ device without it failed pipeline validation, a panic at start.
+- `src/setup.rs`: the default device requests `TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES` when
+ the adapter has it, so 2x and 8x work where the adapter supports them (WebGPU only
+ guarantees 1x and 4x).
diff --git a/vendor/egui-wgpu/src/lib.rs b/vendor/egui-wgpu/src/lib.rs
index 08eee42ba8..b07e452849 100644
--- a/vendor/egui-wgpu/src/lib.rs
+++ b/vendor/egui-wgpu/src/lib.rs
@@ -131,6 +131,10 @@ pub struct RenderState {
/// Custom paint callbacks must use this, rather than the requested setting.
pub msaa_samples: u32,
+ /// SolidCraft: the MSAA sample counts this device can render the target (and depth) format
+ /// with, ascending, always starting with 1.
+ pub msaa_supported: Vec<u32>,
+
/// Egui renderer responsible for drawing the UI.
pub renderer: Arc<RwLock<Renderer>>,
@@ -284,8 +288,19 @@ impl RenderState {
// SolidCraft: the OpenGL resolve path can present an entirely black frame with MSAA
// (notably Mesa/llvmpipe). Decide after selecting the real surface adapter,
// before creating either pipelines or attachments; no second GPU probe.
+ // A sample count the device doesn't support for the target or depth format fails
+ // pipeline validation (a panic at start): fall back to the largest supported one.
+ let msaa_supported =
+ supported_msaa_samples(&adapter, &device, target_format, options.depth_stencil_format);
+ let wanted = effective_msaa_samples(adapter.get_info().backend, options.msaa_samples);
+ let msaa_samples = clamp_msaa_samples(&msaa_supported, wanted);
+ if msaa_samples != wanted {
+ log::warn!(
+ "MSAA {wanted}x is not supported for {target_format:?} on this device (supported: {msaa_supported:?}); using {msaa_samples}x"
+ );
+ }
let options = RendererOptions {
- msaa_samples: effective_msaa_samples(adapter.get_info().backend, options.msaa_samples),
+ msaa_samples,
..options
};
let renderer = Renderer::new(&device, target_format, options);
@@ -302,6 +317,7 @@ impl RenderState {
queue,
target_format,
msaa_samples: options.msaa_samples,
+ msaa_supported,
renderer: Arc::new(RwLock::new(renderer)),
surface_config: config.surface,
})
@@ -571,6 +587,58 @@ pub fn effective_msaa_samples(backend: wgpu::Backend, requested: u32) -> u32 {
if backend == wgpu::Backend::Gl { 1 } else { requested.max(1) }
}
+/// SolidCraft: the MSAA sample counts `device` can render `target_format` and
+/// `depth_stencil_format` with (ascending, always starting with 1). Without
+/// [`wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] the device allows only the counts
+/// WebGPU guarantees for a format (1 and 4), whatever the adapter could do.
+pub fn supported_msaa_samples(
+ adapter: &wgpu::Adapter,
+ device: &wgpu::Device,
+ target_format: wgpu::TextureFormat,
+ depth_stencil_format: Option<wgpu::TextureFormat>,
+) -> Vec<u32> {
+ let features = device.features();
+ let flags = |format: wgpu::TextureFormat| {
+ if features.contains(wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES) {
+ adapter.get_texture_format_features(format).flags
+ } else {
+ format.guaranteed_format_features(features).flags
+ }
+ };
+ let target = flags(target_format);
+ let depth = depth_stencil_format.map(flags);
+ msaa_counts(target, depth)
+}
+
+/// The sample counts both the colour target and the depth buffer support. A multisampled colour
+/// target must also resolve into the single-sampled surface.
+fn msaa_counts(
+ target: wgpu::TextureFormatFeatureFlags,
+ depth: Option<wgpu::TextureFormatFeatureFlags>,
+) -> Vec<u32> {
+ let resolves = target.contains(wgpu::TextureFormatFeatureFlags::MULTISAMPLE_RESOLVE);
+ [1, 2, 4, 8, 16]
+ .into_iter()
+ .filter(|&n| {
+ n == 1
+ || (resolves
+ && target.sample_count_supported(n)
+ && depth.is_none_or(|d| d.sample_count_supported(n)))
+ })
+ .collect()
+}
+
+/// SolidCraft: the largest of the `supported` sample counts that is at most `requested` (1 when
+/// none is).
+pub fn clamp_msaa_samples(supported: &[u32], requested: u32) -> u32 {
+ supported
+ .iter()
+ .copied()
+ .filter(|&n| n <= requested.max(1))
+ .max()
+ .unwrap_or(1)
+}
+
#[cfg(test)]
mod msaa_tests {
#[test]
@@ -582,4 +650,23 @@ mod msaa_tests {
}
}
}
+
+ #[test]
+ fn unsupported_sample_counts_fall_back_to_the_largest_supported_one() {
+ use wgpu::TextureFormatFeatureFlags as F;
+ // WebGPU's guarantee for Bgra8Unorm without adapter-specific features: 1 and 4 (a
+ // saved 8x failed pipeline validation at start).
+ let guaranteed = F::MULTISAMPLE_X4 | F::MULTISAMPLE_RESOLVE;
+ let supported = super::msaa_counts(guaranteed, Some(F::MULTISAMPLE_X4));
+ assert_eq!(supported, [1, 4]);
+ assert_eq!(super::clamp_msaa_samples(&supported, 8), 4);
+ assert_eq!(super::clamp_msaa_samples(&supported, 2), 1);
+ assert_eq!(super::clamp_msaa_samples(&supported, 0), 1);
+ // The depth buffer limits it too, and a target that can't resolve can't multisample.
+ let adapter = F::MULTISAMPLE_X2 | F::MULTISAMPLE_X4 | F::MULTISAMPLE_X8 | F::MULTISAMPLE_RESOLVE;
+ assert_eq!(super::msaa_counts(adapter, None), [1, 2, 4, 8]);
+ assert_eq!(super::msaa_counts(adapter, Some(F::MULTISAMPLE_X4)), [1, 4]);
+ assert_eq!(super::msaa_counts(F::MULTISAMPLE_X4, None), [1]);
+ assert_eq!(super::clamp_msaa_samples(&[], 8), 1);
+ }
}
diff --git a/vendor/egui-wgpu/src/setup.rs b/vendor/egui-wgpu/src/setup.rs
index 3c9ceae5d3..ef2fa48b9f 100644
--- a/vendor/egui-wgpu/src/setup.rs
+++ b/vendor/egui-wgpu/src/setup.rs
@@ -272,6 +272,10 @@ impl WgpuSetupCreateNew {
max_texture_dimension_2d: 8192,
..base_limits
},
+ // SolidCraft: without it only the sample counts WebGPU guarantees (1x, 4x)
+ // are allowed, even where the adapter supports 2x and 8x.
+ required_features: adapter.features()
+ & wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES,
..Default::default()
}
}),