Viewport: hidden edges no longer show through faces, and thin or coplanar faces stop z-fighting (#1434, #1739) (#1768)

Thanks @CamWight.

apps/solidcraft-web/src/main.rs

@@ -27,7 +27,9 @@ mod web {
 
     const CANVAS_ID: &str = "solidcraft_canvas";
     const LOADING_ID: &str = "solidcraft_loading";
-    const DEPTH_BITS: u8 = 24;
+    /// A 32-bit float depth buffer (no stencil): WebGPU and WebGL2 both have it, and the viewport
+    /// draws it with reversed depth, whose precision follows the distance from the eye (#1434).
+    const DEPTH_BITS: u8 = 32;
 
     /// Seconds between autosaves of unsaved work.
     const AUTOSAVE_S: f64 = 30.0;

apps/solidcraft/src/main.rs

@@ -416,6 +416,10 @@ fn msaa() -> u16 {
 const CUSTOM_TITLEBAR: bool = !cfg!(target_os = "macos");
 
 const DEPTH_BITS: u8 = 24;
+/// A 32-bit float depth buffer, drawn with reversed depth (1 near, 0 far) so its precision follows
+/// the distance from the eye (#1434). Only where every adapter offers it with a stencil
+/// ([`startup::float_depth_everywhere`]); else [`DEPTH_BITS`]. Not in safe mode.
+const FLOAT_DEPTH_BITS: u8 = 32;
 /// The section cap marks where it shows in the stencil.
 const STENCIL_BITS: u8 = 8;
 const MSAA: u16 = 4;
@@ -497,6 +501,8 @@ fn main() -> eframe::Result {
         notes.push("Safe mode: default settings (yours are kept for the next normal start), no recovery offer, software rendering.".into());
     }
     let samples = if safe_mode { MSAA } 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 };
     // Crashes leave a report in the crash folder (solidcraft_engine::crash, docs/crash-reports.md).
     let crashed = solidcraft_engine::crash::default_dir()
         .map(|dir| {
@@ -516,7 +522,7 @@ fn main() -> eframe::Result {
     solidcraft_engine::crash::phase("window");
     let options = eframe::NativeOptions {
         viewport: app_viewport()?,
-        depth_buffer: DEPTH_BITS,
+        depth_buffer: depth_bits,
         stencil_buffer: STENCIL_BITS,
         multisampling: samples,
         // Kept with the other settings, not in a folder named after the app id. Safe mode reads
@@ -529,7 +535,7 @@ fn main() -> eframe::Result {
             settings.as_ref().map(|d| d.join("app.ron"))
         },
         persist_window: !safe_mode,
-        wgpu_options: wgpu_options(cpu_renderer, if safe_mode { None } else { backend_preference() }.as_deref()),
+        wgpu_options,
         ..Default::default()
     };
     #[cfg(all(unix, not(target_os = "macos")))]
@@ -579,7 +585,7 @@ 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);
                 solidcraft_engine::crash::phase("viewport pipelines (shader compile)");
-                app.set_wgpu(rs, DEPTH_BITS, STENCIL_BITS, rs.msaa_samples);
+                app.set_wgpu(rs, depth_bits, STENCIL_BITS, rs.msaa_samples);
                 solidcraft_ui_egui::gpu::install_picture_renderer(rs);
                 // The graphics driver is loaded now; it may have put its own exception filter
                 // in front of ours.
@@ -685,6 +691,13 @@ fn wgpu_options(cpu: bool, preference: Option<&str>) -> eframe::egui_wgpu::WgpuC
         if cpu {
             setup.native_adapter_selector = Some(std::sync::Arc::new(startup::pick_cpu_adapter));
         }
+        // A float depth buffer with a stencil, wherever the adapter has it (see `FLOAT_DEPTH_BITS`).
+        let base = setup.device_descriptor.clone();
+        setup.device_descriptor = std::sync::Arc::new(move |adapter| {
+            let mut d = base(adapter);
+            d.required_features |= adapter.features() & startup::FLOAT_DEPTH_STENCIL;
+            d
+        });
     }
     options
 }

apps/solidcraft/src/startup.rs

@@ -157,6 +157,23 @@ pub fn choose_backends(
     Some(WINDOWS_ORDER.into_iter().find(|b| has_hardware(*b)).unwrap_or(Backends::DX12))
 }
 
+/// 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;
+
+/// Whether every adapter `options` could start offers a float depth buffer with a stencil. eframe
+/// makes the window's depth buffer from the depth bits before it picks the adapter, so the window
+/// asks for a float one only when whichever it picks has it.
+pub fn float_depth_everywhere(options: &eframe::egui_wgpu::WgpuConfiguration) -> bool {
+    let eframe::egui_wgpu::WgpuSetup::CreateNew(setup) = &options.wgpu_setup else { return false };
+    let mut desc = eframe::wgpu::InstanceDescriptor::new_without_display_handle_from_env();
+    desc.backends = setup.instance_descriptor.backends;
+    let instance = eframe::wgpu::Instance::new(desc);
+    let adapters = pollster::block_on(instance.enumerate_adapters(setup.instance_descriptor.backends));
+    let all = !adapters.is_empty() && adapters.iter().all(|a| a.features().contains(FLOAT_DEPTH_STENCIL));
+    log::info!("graphics: float depth with stencil on every adapter: {all}");
+    all
+}
+
 /// The order backends are tried in on Windows.
 pub const WINDOWS_ORDER: [eframe::wgpu::Backends; 3] = [eframe::wgpu::Backends::DX12, eframe::wgpu::Backends::VULKAN, eframe::wgpu::Backends::GL];