diff --git a/assets/locales/pending/gpu-memory-lowered.json b/assets/locales/pending/gpu-memory-lowered.json new file mode 100644 index 000000000..1c445c660 --- /dev/null +++ b/assets/locales/pending/gpu-memory-lowered.json @@ -0,0 +1,23 @@ +{ + "en": { + "ui.gpu_memory_lowered": "The graphics card is out of memory: the view is drawn at a lower quality." + }, + "ar": { + "ui.gpu_memory_lowered": "نفدت ذاكرة بطاقة الرسومات: يُرسم العرض بجودة أقل." + }, + "de": { + "ui.gpu_memory_lowered": "Die Grafikkarte hat keinen Speicher mehr frei: Die Ansicht wird in geringerer Qualität gezeichnet." + }, + "he": { + "ui.gpu_memory_lowered": "הזיכרון של כרטיס המסך אזל: התצוגה מוצגת באיכות נמוכה יותר." + }, + "ja": { + "ui.gpu_memory_lowered": "グラフィックカードのメモリが不足しています。ビューは低い画質で描画されます。" + }, + "vi": { + "ui.gpu_memory_lowered": "Card đồ họa đã hết bộ nhớ: khung nhìn được vẽ với chất lượng thấp hơn." + }, + "zh": { + "ui.gpu_memory_lowered": "显卡内存不足:视图以较低画质绘制。" + } +} diff --git a/crates/gpu/src/view.rs b/crates/gpu/src/view.rs index 467e1a0c2..2ae93b40f 100644 --- a/crates/gpu/src/view.rs +++ b/crates/gpu/src/view.rs @@ -175,6 +175,9 @@ pub struct DrawStats { pub line_segments: u64, /// The frame was drawn supersampled and filtered down. pub supersampled: bool, + /// The device refused the memory for a frame (#7296): the view is drawn at a lower + /// resolution, or with its see-through surfaces sorted. + pub lowered: bool, } /// What the last scene change uploaded to the GPU, in bytes: what an edit costs beyond the CPU @@ -224,7 +227,13 @@ impl Tally { } fn stats(&self) -> DrawStats { - DrawStats { draw_calls: self.calls.get(), triangles: self.triangles.get(), line_segments: self.segments.get(), supersampled: false } + DrawStats { + draw_calls: self.calls.get(), + triangles: self.triangles.get(), + line_segments: self.segments.get(), + supersampled: false, + lowered: false, + } } } @@ -2033,6 +2042,13 @@ pub struct Renderer { /// The filtered picture at the viewport's own size, made on the first still frame and blitted /// as it is until the content changes: a still view does not pay for the filter every frame. cached: Option, + /// The device refused the cached picture's texture: still frames are filtered every time. + no_cache: bool, + /// Most memory (bytes) an offscreen frame may take ([`frame_bytes`]): [`SS_BUDGET`], halved + /// below each frame the device refused (out of video memory, #7296). + frame_budget: u64, + /// The device refused memory for a frame or its see-through targets ([`DrawStats::lowered`]). + lowered: bool, /// Reversed depth drawn into the window's pass: egui clears its depth to 1, which is the near /// plane then, so the viewport first sets its rectangle to the far plane (0). depth_reset: Option, @@ -2078,11 +2094,23 @@ struct CachedPicture { /// Most memory (bytes) a supersampled frame's colour and depth may take. const SS_BUDGET: u64 = 384 << 20; +/// The least [`Renderer::frame_budget`] falls to after refused frames: about 256 × 256 pixels at +/// 4× MSAA. +const MIN_FRAME_BUDGET: u64 = 2 << 20; + +/// How many smaller frames one frame asks for after the device refuses one. +const FRAME_TRIES: usize = 8; + /// The size (px) to draw a `size` viewport supersampled `factor` times in each direction: /// within the device's largest texture side (#869) and the memory budget (at `samples` per pixel, /// four bytes of colour and four of depth each). `None` when that leaves under 1.25×: the frame /// is drawn as usual. A `factor` under 1 draws it that much smaller, to be filtered up. pub fn supersampled_size(size: [f32; 2], factor: f32, max_side: u32, samples: u32) -> Option<[u32; 2]> { + supersampled_within(size, factor, max_side, samples, SS_BUDGET) +} + +/// [`supersampled_size`] within `budget` bytes instead of [`SS_BUDGET`]. +fn supersampled_within(size: [f32; 2], factor: f32, max_side: u32, samples: u32, budget: u64) -> Option<[u32; 2]> { let [w, h] = size; if w >= 1.0 && h >= 1.0 && factor > 0.0 && factor < 1.0 { return Some([((w * factor).floor() as u32).clamp(1, max_side.max(1)), ((h * factor).floor() as u32).clamp(1, max_side.max(1))]); @@ -2092,11 +2120,45 @@ pub fn supersampled_size(size: [f32; 2], factor: f32, max_side: u32, samples: u3 } let side = max_side as f32; let bytes_per_px = 8.0 * samples.max(1) as f32; - let by_memory = (SS_BUDGET as f32 / (w * h * bytes_per_px)).sqrt(); + let by_memory = (budget as f32 / (w * h * bytes_per_px)).sqrt(); let f = factor.min(side / w).min(side / h).min(by_memory); (f >= 1.25).then(|| [((w * f).floor() as u32).clamp(1, max_side), ((h * f).floor() as u32).clamp(1, max_side)]) } +/// The memory (bytes) a frame of `size` pixels at `samples` per pixel takes by the measure of +/// the budgets: four bytes of colour and four of depth per sample. +fn frame_bytes(size: [u32; 2], samples: u32) -> u64 { + u64::from(size[0]) * u64::from(size[1]) * 8 * u64::from(samples.max(1)) +} + +/// `size` made smaller, keeping its shape, until its frame ([`frame_bytes`]) fits `budget`: a +/// device that refused a frame of the viewport's own size draws it smaller, filtered up (#7296). +/// At least 1 × 1. +fn fitted_size(size: [u32; 2], samples: u32, budget: u64) -> [u32; 2] { + let bytes = frame_bytes(size, samples); + if bytes <= budget { + return size; + } + let f = (budget as f64 / bytes as f64).sqrt(); + size.map(|side| ((f64::from(side) * f).floor() as u32).max(1)) +} + +/// `make`'s value, or the error the device raised while it ran. A texture the device has no +/// memory for (#7296) would otherwise reach the uncaptured-error handler (a panic by default) +/// and be drawn into, invalid, every frame. A browser answers later and is not waited for (no +/// error is assumed). +fn allocated(device: &wgpu::Device, make: impl FnOnce() -> T) -> Result { + let scopes = [wgpu::ErrorFilter::OutOfMemory, wgpu::ErrorFilter::Internal, wgpu::ErrorFilter::Validation].map(|f| device.push_error_scope(f)); + let value = make(); + let mut failed = None; + for scope in scopes.into_iter().rev() { + if let Some(e) = crate::popped(scope.pop()) { + failed.get_or_insert(e); + } + } + failed.map_or(Ok(value), Err) +} + /// The filter: each viewport pixel the mean of the supersampled pixels under it (four bilinear /// taps a quarter of its footprint from its centre: exactly the 2 × 2 box at 2×). const SS_SHADER: &str = r#" @@ -2805,6 +2867,9 @@ impl Renderer { ss_stats: DrawStats::default(), ss_key: None, cached: None, + no_cache: false, + frame_budget: SS_BUDGET, + lowered: false, image: image.join(), image_bgl, sampler, @@ -3285,6 +3350,12 @@ impl Renderer { self.publish(DrawStats { draw_calls: self.ss_stats.draw_calls + 1, supersampled: self.ss_scaled, ..self.ss_stats }); return; } + // The pipelines draw into the scene's kind of target, not the window's pass: with no + // offscreen frame (the device had no memory for one, #7296) nothing can be drawn. + if self.window_differs() { + self.publish(DrawStats::default()); + return; + } let tally = Tally::default(); if let Some(reset) = &self.depth_reset { pass.set_pipeline(reset); @@ -3307,7 +3378,7 @@ impl Renderer { fn publish(&self, drawn: DrawStats) { if let Ok(mut s) = self.stats.lock() { - *s = drawn; + *s = DrawStats { lowered: self.lowered, ..drawn }; } } @@ -3631,21 +3702,32 @@ impl Renderer { fn cache_picture(&mut self, device: &wgpu::Device, encoder: &mut wgpu::CommandEncoder, size_px: [f32; 2]) { let Some(ss) = &self.ss else { return }; let [w, h] = size_px; - if !(w >= 1.0 && h >= 1.0) { + if !(w >= 1.0 && h >= 1.0) || self.no_cache { return; } let max = self.max_texture.max(1); let size = [(w.round() as u32).clamp(1, max), (h.round() as u32).clamp(1, max)]; - let texture = device.create_texture(&wgpu::TextureDescriptor { - label: Some("sc_ssaa_cached"), - size: wgpu::Extent3d { width: size[0], height: size[1], depth_or_array_layers: 1 }, - mip_level_count: 1, - sample_count: 1, - dimension: wgpu::TextureDimension::D2, - format: self.target.format, - usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, - view_formats: &[], + let made = allocated(device, || { + device.create_texture(&wgpu::TextureDescriptor { + label: Some("sc_ssaa_cached"), + size: wgpu::Extent3d { width: size[0], height: size[1], depth_or_array_layers: 1 }, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: self.target.format, + usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, + view_formats: &[], + }) }); + let texture = match made { + Ok(texture) => texture, + Err(e) => { + log::warn!("still frames are filtered every time: the GPU refused a {} × {} picture: {e}", size[0], size[1]); + self.no_cache = true; + self.lowered = true; + return; + } + }; let view = texture.create_view(&Default::default()); let bind = device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("sc_ssaa_cached"), @@ -3683,27 +3765,66 @@ impl Renderer { fn supersample(&mut self, device: &wgpu::Device, encoder: &mut wgpu::CommandEncoder, cb: &Frame, see_through: bool) -> bool { // Supersampled when asked (and worth it); else, for order-independent transparency, at // the viewport's own size. + let max = self.max_texture.max(1); let own = || { let [w, h] = cb.size_px; - (w >= 1.0 && h >= 1.0) - .then(|| [(w.round() as u32).clamp(1, self.max_texture.max(1)), (h.round() as u32).clamp(1, self.max_texture.max(1))]) + (w >= 1.0 && h >= 1.0).then(|| [(w.round() as u32).clamp(1, max), (h.round() as u32).clamp(1, max)]) }; - let scaled = if cb.ssaa != 1.0 { supersampled_size(cb.size_px, cb.ssaa, self.max_texture, self.target.samples) } else { None }; // See-through surfaces (order-independent transparency) and a window pass of another kind // (samples, depth) need a frame of their own, even at the viewport's own size. - let Some(size) = scaled.or_else(|| if see_through || self.window_differs() { own() } else { None }) else { + let needs_own = see_through || self.window_differs(); + let samples = self.target.samples; + let mut drawn = None; + for _ in 0..FRAME_TRIES { + let budget = self.frame_budget; + let scaled = if cb.ssaa != 1.0 { supersampled_within(cb.size_px, cb.ssaa, self.max_texture, samples, budget) } else { None }; + // After refused frames, one of the viewport's own size may not fit either: it is drawn + // smaller and filtered up. + let frame = scaled.map(|s| (s, true)).or_else(|| { + needs_own.then(own).flatten().map(|s| { + let fitted = fitted_size(s, samples, budget); + (fitted, fitted != s) + }) + }); + let Some((size, filtered)) = frame else { + self.ss = None; + return false; + }; + if self.ss.as_ref().is_some_and(|ss| ss.size == size) { + drawn = Some((size, filtered)); + break; + } + // The old frame goes before the new one is asked for. self.ss = None; - return false; - }; - self.ss_scaled = scaled.is_some(); - if self.ss.as_ref().is_none_or(|ss| ss.size != size) { - self.ss = Some(self.supersampled(device, size)); + match allocated(device, || self.supersampled(device, size)) { + Ok(ss) => { + self.ss = Some(ss); + drawn = Some((size, filtered)); + break; + } + Err(e) => { + let before = self.frame_budget; + self.refused(size, &e); + // Already at the least budget: no smaller frame to ask for. + if self.frame_budget == before { + break; + } + } + } } - if see_through - && let Some(p) = &self.oit - && self.oit_targets.as_ref().is_none_or(|t| t.size != size) - { - self.oit_targets = Some(p.targets(device, size, self.target.samples)); + let Some((size, filtered)) = drawn else { return false }; + self.ss_scaled = filtered; + if see_through && self.oit_targets.as_ref().is_none_or(|t| t.size != size) { + self.oit_targets = None; + match self.oit.as_ref().map(|p| allocated(device, || p.targets(device, size, samples))) { + Some(Ok(targets)) => self.oit_targets = Some(targets), + Some(Err(e)) => { + log::warn!("see-through surfaces are sorted: the GPU refused their {} × {} targets: {e}", size[0], size[1]); + self.oit = None; + self.lowered = true; + } + None => {} + } } let Some(ss) = &self.ss else { return false }; let depth_format = self.target.depth; @@ -3758,6 +3879,14 @@ impl Renderer { true } + /// The device refused a frame of `size` pixels (out of video memory, #7296): the next one + /// asked for takes at most half its memory. + fn refused(&mut self, size: [u32; 2], e: &wgpu::Error) { + self.frame_budget = (self.frame_budget.min(frame_bytes(size, self.target.samples)) / 2).max(MIN_FRAME_BUDGET); + self.lowered = true; + log::warn!("the view is drawn at a lower resolution: the GPU refused a {} × {} frame: {e}", size[0], size[1]); + } + /// Textures for a supersampled frame of `size` pixels. fn supersampled(&self, device: &wgpu::Device, size: [u32; 2]) -> Supersampled { let t = self.target; @@ -4574,6 +4703,43 @@ mod glass_tests { assert!(max <= 1, "the blitted picture matches the direct one (max difference {max})"); } + /// A GT 740 had no video memory left for the viewport's frame, and the app closed with "wgpu + /// error: Out of Memory" (#7296). A frame the device refuses is drawn smaller instead, and the + /// device's refusals are reported. A texture past the device's largest side stands in for + /// one past its memory: the renderer is told the device takes larger textures than it does, + /// and the device refuses them the same way. An error that escaped would panic here (the + /// test device keeps wgpu's default handler). + #[test] + fn a_frame_the_device_refuses_is_drawn_smaller() { + let Some((_, device, queue)) = crate::open_headless().ok() else { return }; + let depth = crate::depth_format(&device, true); + let format = wgpu::TextureFormat::Rgba8Unorm; + let scene_target = GpuTarget { format, depth: Some(depth), samples: 1, tess: false, oit: false }; + let window_target = GpuTarget { format, depth: None, samples: 1, tess: false, oit: false }; + let limit = device.limits().max_texture_dimension_2d; + let red = |pixels: &[u8]| pixels.get((32 * 64 + 32) * 4..(32 * 64 + 32) * 4 + 4).is_some_and(|p| p[0] > 200 && p[1] < 60 && p[2] < 60); + // Supersampled 4× (a wide, flat viewport) and at the viewport's own size: each frame is + // refused at first, so drawn smaller, and the view still shows the model. + for (width, ssaa) in [(limit / 2 + 64, 4.0), (limit * 2, 1.0)] { + let mut r = Renderer::with_window_target(&device, scene_target, window_target, None); + r.max_texture = limit.saturating_mul(4); + let mut frame = test_frame(test_scene(), ssaa); + frame.size_px = [width as f32, 64.0]; + let shown = render_frame(&mut r, &device, &queue, &frame, false); + let size = r.ss.as_ref().map(|ss| ss.size); + assert!(r.ss_ready && size.is_some_and(|[w, _]| w <= limit), "{width} px at {ssaa}×: drawn within the device ({size:?})"); + assert!(red(&shown), "{width} px at {ssaa}×: the view shows the model"); + let stats = r.stats().lock().map(|s| *s).unwrap_or_default(); + assert!(stats.lowered, "{width} px at {ssaa}×: the lower quality is reported"); + // The next frame asks for no more than the device gave. + let budget = r.frame_budget; + frame.view_proj[3][0] += 0.01; + assert!( + red(&render_frame(&mut r, &device, &queue, &frame, false)) && r.frame_budget == budget && r.ss.as_ref().map(|ss| ss.size) == size + ); + } + } + /// The Render workspace's preview once painted the modelling viewport's last frame instead of /// its own (#5119): after a frame with see-through surfaces, drawn offscreen for /// order-independent transparency, it stayed frozen on that frame whatever the camera did. diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs index 49ab68431..e3de2e971 100644 --- a/crates/ui-egui/src/viewport.rs +++ b/crates/ui-egui/src/viewport.rs @@ -118,6 +118,10 @@ pub struct ViewportState { pub(crate) tess_ready: Option, /// What the GPU drew last frame, shared with the renderer (the frame-rate details, #2548). pub(crate) draw_stats: Option, + /// The status line has said the view is drawn at a lower quality ([`DrawStats::lowered`]). + /// + /// [`DrawStats::lowered`]: crate::gpu::DrawStats::lowered + lowered_noted: bool, /// The graphics backend and adapter, as the frame-rate details show them. pub(crate) adapter: String, slot: SceneSlot, @@ -3933,6 +3937,12 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { }, }); painter.add(egui_wgpu::Callback::new_paint_callback(rect, cb)); + // The graphics card had no memory for the view's frame (#7296): say once why it looks + // coarser. + if !app.viewport.lowered_noted && app.viewport.draw_stats.as_ref().is_some_and(|s| s.lock().is_ok_and(|s| s.lowered)) { + app.viewport.lowered_noted = true; + app.set_status(app.tr("ui.gpu_memory_lowered"), false); + } } let overlay_rect = crate::shell::bottom_overlay_rect(app, rect); analysis_legend(app, &painter, overlay_rect);