Skip to content

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

Viewport: reuse still pictures and draw scenes into a 1x window pass (#4820) (#5187)

Jackson Oursland5962f56f87d4
diff --git a/apps/solidcraft/src/main.rs b/apps/solidcraft/src/main.rs
index 72ab4d6f95..c63bc4811a 100644
--- a/apps/solidcraft/src/main.rs
+++ b/apps/solidcraft/src/main.rs
@@ -624,9 +624,11 @@ fn main() -> eframe::Result {
solidcraft_engine::crash::phase("window");
let options = eframe::NativeOptions {
viewport: app_viewport()?,
- depth_buffer: depth_bits,
- stencil_buffer: STENCIL_BITS,
- multisampling: samples,
+ // The window's pass (egui's) has no depth and one sample: the viewport draws its scene
+ // offscreen with its own depth and MSAA, then blits it, so the UI pass pays for neither.
+ depth_buffer: 0,
+ stencil_buffer: 0,
+ multisampling: 1,
// Kept with the other settings, not in a folder named after the app id. Safe mode reads
// and writes a scratch copy, leaving the user's settings as they were.
persistence_path: if safe_mode {
@@ -695,9 +697,19 @@ fn main() -> eframe::Result {
lost_at: None,
});
if let Some(rs) = &cc.wgpu_render_state {
- eprintln!("SolidCraft graphics: {:?}, MSAA {}x (requested {}x)", rs.adapter.get_info().backend, rs.msaa_samples, samples);
+ // The viewport's scene keeps the app's anti-aliasing; the window's pass is 1x.
+ // A count the device cannot render with falls back to the supported default.
+ let scene_samples = {
+ let requested = u32::from(samples).max(1);
+ if requested <= 1 || rs.msaa_supported.is_empty() || rs.msaa_supported.contains(&requested) {
+ requested
+ } else {
+ rs.msaa_supported.iter().copied().filter(|&n| n <= solidcraft_ui_egui::prefs::Prefs::default().msaa).max().unwrap_or(1)
+ }
+ };
+ eprintln!("SolidCraft graphics: {:?}, MSAA {scene_samples}x (requested {}x)", rs.adapter.get_info().backend, samples);
solidcraft_engine::crash::phase("viewport pipelines (shader compile)");
- app.set_wgpu(rs, depth_bits, STENCIL_BITS, rs.msaa_samples);
+ app.set_wgpu_split(rs, depth_bits, STENCIL_BITS, scene_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.
@@ -707,8 +719,8 @@ fn main() -> eframe::Result {
solidcraft_ui_egui::prefs::check_msaa(&mut app, u32::from(samples));
let info = rs.adapter.get_info();
solidcraft_engine::crash::set_environment(&format!(
- "Renderer: {:?} {} ({}), MSAA {}x",
- info.backend, info.name, info.driver, rs.msaa_samples
+ "Renderer: {:?} {} ({}), MSAA {scene_samples}x",
+ info.backend, info.name, info.driver
));
}
mark("viewport pipelines");
diff --git a/apps/solidcraft/src/space_mouse.rs b/apps/solidcraft/src/space_mouse.rs
index 8a9c31818a..c037f8f6c6 100644
--- a/apps/solidcraft/src/space_mouse.rs
+++ b/apps/solidcraft/src/space_mouse.rs
@@ -284,15 +284,18 @@ fn decode_report(report: &[u8], layout: Layout, reading: &mut Reading, now: Inst
true
}
-/// Publishes one input report from the device to the egui thread.
+/// Publishes one input report from the device to the egui thread. A report that reads the same as
+/// the reading it replaces is no news — a device may repeat its report at rest — so it asks for no
+/// frame; while the cap moves, the view asks for the next frame itself.
fn publish(ctx: &Context, shared: &Mutex<Reading>, layout: Layout, report: &[u8]) {
if DRIVER_CONNECTED.load(Ordering::Relaxed) {
return;
}
- if let Ok(mut reading) = shared.lock()
- && decode_report(report, layout, &mut reading, Instant::now())
- {
- ctx.request_repaint();
+ if let Ok(mut reading) = shared.lock() {
+ let before = reading.axes;
+ if decode_report(report, layout, &mut reading, Instant::now()) && reading.axes != before {
+ ctx.request_repaint();
+ }
}
}
@@ -886,6 +889,31 @@ mod tests {
assert_eq!(reading.current(now + STALE_AFTER, Axes::default()).translation, [0; 3]);
}
+ /// A device that repeats its reading at rest asks for no frame; a reading that changes does.
+ #[test]
+ fn a_repeated_report_at_rest_asks_for_no_frame() {
+ let ctx = Context::default();
+ let shared = Mutex::new(Reading::new(Instant::now()));
+ let layout = Layout::default();
+ let frame = || {
+ let mut out = ctx.run_ui(egui::RawInput::default(), |_| {});
+ out.textures_delta.clear();
+ };
+ let asked = || {
+ frame();
+ ctx.repaint_causes().iter().any(|c| c.file.ends_with("space_mouse.rs"))
+ };
+ frame();
+ // Report 1 carries translation (see the split-layout test).
+ let report = [1, 0x9c, 0xff, 0x2c, 0x01, 0, 0];
+ publish(&ctx, &shared, layout, &report);
+ assert!(asked(), "a report that moves the cap asks for a frame");
+ publish(&ctx, &shared, layout, &report);
+ assert!(!asked(), "the same reading at rest is no news");
+ publish(&ctx, &shared, layout, &[1, 0x9d, 0xff, 0x2c, 0x01, 0, 0]);
+ assert!(asked(), "a changed reading asks for a frame");
+ }
+
#[test]
fn a_held_reading_stays_until_the_next_one_and_a_hid_reading_goes_stale() {
let now = Instant::now();
diff --git a/crates/gpu/src/view.rs b/crates/gpu/src/view.rs
index c2f25b40b6..07a0acd8ff 100644
--- a/crates/gpu/src/view.rs
+++ b/crates/gpu/src/view.rs
@@ -3,9 +3,11 @@
//! any wgpu device. The desktop and web viewport draws through it (an `egui_wgpu` paint callback
//! hands it the device and the pass); headless pictures draw through it offscreen
//! ([`crate::capture`]). Geometry is uploaded when a scene changes; each frame only the camera
-//! uniform changes. Where the device runs compute shaders, opaque bodies are drawn straight from
-//! their display plans: the plan is evaluated on the GPU into the vertex buffer the pass draws
-//! (see [`PlannedBody`]), with nothing built or read back on the CPU.
+//! uniform changes. A frame that would draw the same picture as the last is blitted from that
+//! picture's texture instead, so a still view costs nothing to show again. Where the device runs
+//! compute shaders, opaque bodies are drawn straight from their display plans: the plan is
+//! evaluated on the GPU into the vertex buffer the pass draws (see [`PlannedBody`]), with nothing
+//! built or read back on the CPU.
use std::sync::{Arc, Mutex};
@@ -1114,10 +1116,16 @@ pub struct Renderer {
/// The target the pipelines draw into (format, depth, samples): a supersampled frame is
/// drawn into textures of the same kind.
target: GpuTarget,
+ /// The pass the picture is shown in (egui's): its samples and depth. Equal to [`Self::target`]
+ /// unless the scene is drawn offscreen and blitted ([`Self::window_differs`]).
+ window: GpuTarget,
/// The device's largest 2D texture side (#869).
max_texture: u32,
/// Supersampling (#1288): the filter that draws the supersampled frame into the viewport.
ss_blit: wgpu::RenderPipeline,
+ /// The same filter into an offscreen texture of its own (no depth, one sample): the picture
+ /// [`Renderer::cached`] keeps for still frames.
+ ss_filter: wgpu::RenderPipeline,
/// The frame drawn offscreen at the viewport's own size (for the see-through surfaces' order-
/// independent transparency), copied as it is.
copy_blit: wgpu::RenderPipeline,
@@ -1132,6 +1140,12 @@ pub struct Renderer {
ss: Option<Supersampled>,
/// This frame was drawn supersampled (in `prepare`): `paint` only filters it down.
ss_ready: bool,
+ /// What the picture in `ss` shows ([`frame_key`]): a frame whose key matches is blitted, not
+ /// drawn again.
+ ss_key: Option<u64>,
+ /// 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<CachedPicture>,
/// 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<wgpu::RenderPipeline>,
@@ -1164,6 +1178,13 @@ struct Supersampled {
bind: wgpu::BindGroup,
}
+/// A frame filtered down to the viewport's own pixels, for a still view to blit as it is.
+struct CachedPicture {
+ /// Kept for the bind group, which samples it.
+ _view: wgpu::TextureView,
+ bind: wgpu::BindGroup,
+}
+
/// Most memory (bytes) a supersampled frame's colour and depth may take.
const SS_BUDGET: u64 = 384 << 20;
@@ -1385,8 +1406,16 @@ pub fn gpu_view_proj(vp: [[f32; 4]; 4], reversed: bool) -> [[f32; 4]; 4] {
}
impl Renderer {
- /// The pipelines for target `t` on `device`; `tess` evaluates planned bodies on the GPU.
+ /// The pipelines for target `t` on `device`; `tess` evaluates planned bodies on the GPU. The
+ /// frame is drawn into `t` and shown in a pass of the same kind (one target).
pub fn new(device: &wgpu::Device, t: GpuTarget, tess: Option<crate::TessGpu>) -> Self {
+ Self::with_window_target(device, t, t, tess)
+ }
+
+ /// The pipelines for a frame drawn into `t` (the scene target) and shown in a pass of `window`'s
+ /// kind. When the two differ (a 1× window pass with no depth, say, and a multisampled scene
+ /// target), the scene is always drawn offscreen and blitted into the window's pass.
+ pub fn with_window_target(device: &wgpu::Device, t: GpuTarget, window: GpuTarget, tess: Option<crate::TessGpu>) -> Self {
let source = format!("{SHADER}\n{}", pbr::SOURCE);
let module =
device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("sc_viewport"), source: wgpu::ShaderSource::Wgsl(source.into()) });
@@ -1425,6 +1454,16 @@ impl Renderer {
bias: Default::default(),
})
};
+ // The pass the picture is shown in, which may have no depth and one sample.
+ let window_depth = |compare: wgpu::CompareFunction| -> Option<wgpu::DepthStencilState> {
+ window.depth.map(|format| wgpu::DepthStencilState {
+ format,
+ depth_write_enabled: Some(false),
+ depth_compare: Some(depth_compare(window.reversed_depth(), compare)),
+ stencil: Default::default(),
+ bias: Default::default(),
+ })
+ };
// Opaque faces pushed back by their own slope (FACE_BIAS); ghosts twice as far.
let pushed = |compare: wgpu::CompareFunction, write: bool, bias: wgpu::DepthBiasState| -> Option<wgpu::DepthStencilState> {
depth(compare, write).map(|d| wgpu::DepthStencilState { bias: depth_bias(reversed, bias), ..d })
@@ -1674,14 +1713,14 @@ impl Renderer {
});
// The frame is premultiplied (drawn over transparent black), so it goes over the
// viewport's background premultiplied; the viewport's depth is left as it is.
- let blit = |entry: &str| {
+ let blit = |entry: &str, samples: u32, depth_stencil: Option<wgpu::DepthStencilState>| {
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("sc_ssaa"),
layout: Some(&ss_layout),
vertex: wgpu::VertexState { module: &ss_module, entry_point: Some("vs"), buffers: &[], compilation_options: Default::default() },
primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, ..Default::default() },
- depth_stencil: depth(wgpu::CompareFunction::Always, false),
- multisample: wgpu::MultisampleState { count: t.samples.max(1), mask: !0, alpha_to_coverage_enabled: false },
+ depth_stencil,
+ multisample: wgpu::MultisampleState { count: samples, mask: !0, alpha_to_coverage_enabled: false },
fragment: Some(wgpu::FragmentState {
module: &ss_module,
entry_point: Some(entry),
@@ -1696,9 +1735,12 @@ impl Renderer {
cache: None,
})
};
- let (ss_blit, copy_blit) = (blit("fs"), blit("fs_copy"));
+ let pass_depth = window_depth(wgpu::CompareFunction::Always);
+ let (ss_blit, copy_blit) = (blit("fs", window.samples.max(1), pass_depth.clone()), blit("fs_copy", window.samples.max(1), pass_depth));
+ // Into the cached picture's own texture: no depth, one sample.
+ let ss_filter = blit("fs", 1, None);
let oit = oit::Pipelines::new(device, &module, &layout, t.format, t.depth, t.samples);
- let depth_reset = t.depth.filter(|_| reversed).map(|format| {
+ let depth_reset = window.depth.filter(|_| window.reversed_depth()).map(|format| {
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("sc_depth_reset"),
source: wgpu::ShaderSource::Wgsl(DEPTH_RESET_SHADER.into()),
@@ -1720,11 +1762,11 @@ impl Renderer {
stencil: Default::default(),
bias: Default::default(),
}),
- multisample: wgpu::MultisampleState { count: t.samples.max(1), mask: !0, alpha_to_coverage_enabled: false },
+ multisample: wgpu::MultisampleState { count: window.samples.max(1), mask: !0, alpha_to_coverage_enabled: false },
fragment: Some(wgpu::FragmentState {
module: &module,
entry_point: Some("fs"),
- targets: &[Some(wgpu::ColorTargetState { format: t.format, blend: None, write_mask: wgpu::ColorWrites::empty() })],
+ targets: &[Some(wgpu::ColorTargetState { format: window.format, blend: None, write_mask: wgpu::ColorWrites::empty() })],
compilation_options: Default::default(),
}),
multiview_mask: None,
@@ -1735,8 +1777,10 @@ impl Renderer {
ao,
depth_reset,
target: t,
+ window,
max_texture: device.limits().max_texture_dimension_2d,
ss_blit,
+ ss_filter,
copy_blit,
ss_scaled: false,
oit,
@@ -1744,6 +1788,8 @@ impl Renderer {
ss_bgl,
ss: None,
ss_ready: false,
+ ss_key: None,
+ cached: None,
image,
image_bgl,
sampler,
@@ -1927,17 +1973,89 @@ pub fn hangs_on_gpu_tessellation(backend: wgpu::Backend, name: &str) -> bool {
backend == wgpu::Backend::Metal && name.contains("FirePro")
}
+/// Whether [`Renderer::prepare`] may blit the picture it drew last instead of drawing the frame
+/// again: the content is the same and that picture is a texture frame (the direct path has none
+/// to blit).
+fn can_reuse(ss_ready: bool, cached: Option<u64>, key: u64) -> bool {
+ ss_ready && cached == Some(key)
+}
+
+/// Everything the drawn picture depends on: the scene keys and camera, the viewport's size, the
+/// section, images, analysis, accessibility map and ambient occlusion. The same key draws the
+/// same picture (pipelines and shaders are fixed for the renderer).
+fn frame_key(cb: &Frame) -> u64 {
+ use std::hash::Hash as _;
+ let mut h = std::collections::hash_map::DefaultHasher::new();
+ cb.product.hash(&mut h);
+ cb.key.hash(&mut h);
+ cb.sketch_key.hash(&mut h);
+ cb.hl_key.hash(&mut h);
+ cb.pv_key.hash(&mut h);
+ cb.pv_hide.hash(&mut h);
+ cb.view_proj.iter().flatten().for_each(|v| v.to_bits().hash(&mut h));
+ cb.back.map(f32::to_bits).hash(&mut h);
+ cb.eye.map(f32::to_bits).hash(&mut h);
+ cb.size_px.map(f32::to_bits).hash(&mut h);
+ cb.clip.map(f32::to_bits).hash(&mut h);
+ cb.cap.map(f32::to_bits).hash(&mut h);
+ cb.analysis.map(f32::to_bits).hash(&mut h);
+ cb.analysis_colors.map(f32::to_bits).hash(&mut h);
+ cb.outline.hash(&mut h);
+ cb.ao_radius.to_bits().hash(&mut h);
+ cb.ssaa.to_bits().hash(&mut h);
+ for img in &cb.images {
+ img.id.hash(&mut h);
+ img.version.hash(&mut h);
+ img.size.hash(&mut h);
+ img.corners.iter().flatten().for_each(|v| v.to_bits().hash(&mut h));
+ img.opacity.to_bits().hash(&mut h);
+ }
+ match &cb.access {
+ Some(a) => {
+ true.hash(&mut h);
+ a.version.hash(&mut h);
+ a.size.hash(&mut h);
+ a.u.map(f32::to_bits).hash(&mut h);
+ a.v.map(f32::to_bits).hash(&mut h);
+ a.scale.to_bits().hash(&mut h);
+ }
+ None => false.hash(&mut h),
+ }
+ std::hash::Hasher::finish(&h)
+}
+
impl Renderer {
+ /// The scene can't be drawn straight into the window's pass (a different sample count, depth
+ /// or format): it is drawn offscreen and blitted.
+ fn window_differs(&self) -> bool {
+ self.target.samples != self.window.samples || self.target.depth != self.window.depth || self.target.format != self.window.format
+ }
+
/// Before the frame's render pass: upload the scenes that changed (planned bodies not yet on
/// the GPU are evaluated by dispatches recorded into `encoder`), the uniform, the images and
- /// the accessibility map, and draw the frame supersampled when it asks for that.
+ /// the accessibility map, and draw the frame supersampled when it asks for that. A frame whose
+ /// content is the same as the picture drawn last is not drawn again: that picture is blitted
+ /// instead, so pointer moves and UI animations over a still view cost no scene work.
pub fn prepare(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, encoder: &mut wgpu::CommandEncoder, frame: &Frame) {
let res = self;
let cb = frame;
+ let key = frame_key(cb);
+ if can_reuse(res.ss_ready && res.ss.is_some(), res.ss_key, key) {
+ // A still frame shows the picture as it is; the first one filters it down once.
+ if res.ss_scaled && res.cached.is_none() {
+ res.cache_picture(device, encoder, cb.size_px);
+ }
+ return;
+ }
+ res.cached = None;
if cb.product {
res.product.take(device, cb.key, &cb.slot, None);
res.product.sort_glass(queue, cb.back);
queue.write_buffer(&res.uniform, 0, &uniform_bytes(cb, cb.size_px[0], cb.size_px[1], res.linear_out, res.target.reversed_depth()));
+ // The product picture goes through the window's pass too: offscreen when the targets
+ // differ or it is drawn smaller, else straight into the window's pass.
+ res.ss_ready = (res.window_differs() || cb.ssaa != 1.0) && res.supersample(device, encoder, cb, false);
+ res.ss_key = res.ss_ready.then_some(key);
return;
}
res.model.take(device, cb.key, &cb.slot, res.tess.as_ref().map(|t| (t, &mut *encoder)));
@@ -2008,7 +2126,8 @@ impl Renderer {
res.quads.push((img.id, b));
}
}
- res.ss_ready = (cb.ssaa != 1.0 || see_through) && res.supersample(device, encoder, cb, see_through);
+ res.ss_ready = (cb.ssaa != 1.0 || see_through || res.window_differs()) && res.supersample(device, encoder, cb, see_through);
+ res.ss_key = res.ss_ready.then_some(key);
}
/// Draw the frame into `pass` within `viewport` (x, y, width, height in physical pixels):
@@ -2022,8 +2141,14 @@ impl Renderer {
if self.ss_ready
&& let Some(ss) = &self.ss
{
- pass.set_pipeline(if self.ss_scaled { &self.ss_blit } else { &self.copy_blit });
- pass.set_bind_group(0, &ss.bind, &[]);
+ // A still view's picture is already at the viewport's size: blit it as it is.
+ if let Some(cached) = &self.cached {
+ pass.set_pipeline(&self.copy_blit);
+ pass.set_bind_group(0, &cached.bind, &[]);
+ } else {
+ pass.set_pipeline(if self.ss_scaled { &self.ss_blit } else { &self.copy_blit });
+ pass.set_bind_group(0, &ss.bind, &[]);
+ }
pass.draw(0..3, 0..1);
return;
}
@@ -2200,6 +2325,58 @@ impl Renderer {
}
impl Renderer {
+ /// Filter the supersampled picture down to the viewport's own pixels once, into the texture
+ /// [`Renderer::cached`] keeps: still frames then blit it as it is instead of filtering it every
+ /// time.
+ 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) {
+ 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 view = texture.create_view(&Default::default());
+ let bind = device.create_bind_group(&wgpu::BindGroupDescriptor {
+ label: Some("sc_ssaa_cached"),
+ layout: &self.ss_bgl,
+ entries: &[
+ wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(&view) },
+ wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::Sampler(&self.sampler) },
+ ],
+ });
+ {
+ let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+ label: Some("sc_ssaa_cached"),
+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+ view: &view,
+ depth_slice: None,
+ resolve_target: None,
+ ops: wgpu::Operations { load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT), store: wgpu::StoreOp::Store },
+ })],
+ depth_stencil_attachment: None,
+ timestamp_writes: None,
+ occlusion_query_set: None,
+ multiview_mask: None,
+ });
+ pass.set_pipeline(&self.ss_filter);
+ pass.set_bind_group(0, &ss.bind, &[]);
+ pass.set_viewport(0.0, 0.0, size[0] as f32, size[1] as f32, 0.0, 1.0);
+ pass.draw(0..3, 0..1);
+ }
+ self.cached = Some(CachedPicture { _view: view, bind });
+ }
+
/// Draw the frame supersampled (`cb.ssaa` times the viewport's pixels each way, within the
/// device's texture limit and the memory budget) into textures of the viewport's kind.
/// `false` when it cannot be (too small a gain, a zero-sized viewport): drawn as usual.
@@ -2212,7 +2389,9 @@ impl Renderer {
.then(|| [(w.round() as u32).clamp(1, self.max_texture.max(1)), (h.round() as u32).clamp(1, self.max_texture.max(1))])
};
let scaled = if cb.ssaa != 1.0 { supersampled_size(cb.size_px, cb.ssaa, self.max_texture, self.target.samples) } else { None };
- let Some(size) = scaled.or_else(|| if see_through { own() } else { None }) else {
+ // 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 {
self.ss = None;
return false;
};
@@ -2482,6 +2661,97 @@ mod tests {
naga::valid::Validator::new(naga::valid::ValidationFlags::all(), naga::valid::Capabilities::empty()).validate(&module).unwrap();
}
+ /// A frame with a fixed picture, and a key that names everything it shows.
+ fn cached_frame() -> super::Frame {
+ use std::sync::{Arc, Mutex};
+ let slot = || Arc::new(Mutex::new(None));
+ super::Frame {
+ product: false,
+ key: 1,
+ slot: slot(),
+ sketch_key: 2,
+ sketch_slot: slot(),
+ hl_key: 3,
+ hl_slot: slot(),
+ pv_key: 4,
+ pv_slot: slot(),
+ pv_hide: false,
+ view_proj: [[0.0; 4]; 4],
+ back: [0.0; 3],
+ size_px: [800.0, 600.0],
+ clip: [0.0; 4],
+ cap: [0.0; 4],
+ images: Vec::new(),
+ analysis: [0.0; 8],
+ analysis_colors: [0.0; 36],
+ access: None,
+ outline: false,
+ eye: [0.0; 4],
+ ao_radius: 0.0,
+ ssaa: 1.0,
+ }
+ }
+
+ fn image(version: u64) -> super::GpuImage {
+ super::GpuImage { id: 1, version, size: [2, 2], rgba: std::sync::Arc::new(vec![0; 16]), corners: [[0.0; 3]; 4], opacity: 1.0 }
+ }
+
+ fn access(version: u64) -> super::AccessMap {
+ super::AccessMap { version, size: 2, depth: std::sync::Arc::new(vec![0.0; 4]), u: [1.0, 0.0, 0.0, 0.0], v: [0.0, 1.0, 0.0, 0.0], scale: 1.0 }
+ }
+
+ /// A picture is drawn again when anything in it changes; only an identical frame reuses it.
+ #[test]
+ fn a_frame_is_redrawn_when_anything_it_shows_changes() {
+ let key = |change: fn(&mut super::Frame)| {
+ let mut f = cached_frame();
+ change(&mut f);
+ super::frame_key(&f)
+ };
+ let base = key(|_| {});
+ assert_eq!(base, key(|_| {}), "the same frame draws the same picture");
+ for (what, changed) in [
+ ("product", key(|f| f.product = true)),
+ ("model", key(|f| f.key += 1)),
+ ("sketch", key(|f| f.sketch_key += 1)),
+ ("highlight", key(|f| f.hl_key += 1)),
+ ("preview", key(|f| f.pv_key += 1)),
+ ("preview hidden", key(|f| f.pv_hide = true)),
+ ("camera", key(|f| f.view_proj[0][0] += 1.0)),
+ ("lighting", key(|f| f.back[0] += 1.0)),
+ ("eye", key(|f| f.eye[0] += 1.0)),
+ ("size", key(|f| f.size_px[0] += 1.0)),
+ ("section", key(|f| f.clip[0] = 1.0)),
+ ("section cap", key(|f| f.cap[0] = 0.5)),
+ ("analysis", key(|f| f.analysis[0] = 1.0)),
+ ("analysis colours", key(|f| f.analysis_colors[0] = 1.0)),
+ ("outline", key(|f| f.outline = true)),
+ ("ambient occlusion", key(|f| f.ao_radius = 1.0)),
+ ("supersampling", key(|f| f.ssaa = 2.0)),
+ ("image", key(|f| f.images.push(image(1)))),
+ ("image pixels", key(|f| f.images.push(image(2)))),
+ (
+ "image opacity",
+ key(|f| {
+ f.images.push(image(1));
+ if let Some(i) = f.images.first_mut() {
+ i.opacity = 0.5;
+ }
+ }),
+ ),
+ ("accessibility", key(|f| f.access = Some(access(1)))),
+ ("accessibility map", key(|f| f.access = Some(access(2)))),
+ ] {
+ assert_ne!(base, changed, "{what} must draw again");
+ }
+ // The comparison a frame makes: only a frame drawn into a texture has a picture to blit,
+ // and only the picture with the same content is shown again.
+ assert!(super::can_reuse(true, Some(base), base));
+ assert!(!super::can_reuse(true, Some(base), base + 1));
+ assert!(!super::can_reuse(false, Some(base), base));
+ assert!(!super::can_reuse(true, None, base));
+ }
+
/// Derivatives and implicit-lod sampling run only in uniform control flow: browsers' WGSL
/// compilers (Tint) reject them after a branch, and the whole viewport shader then fails,
/// a black screen on the web (naga accepts it). Every fragment entry point makes such calls
@@ -2727,6 +2997,159 @@ mod glass_tests {
bytes.get(at..at + 4).and_then(|p| p.try_into().ok())
}
+ /// Render `frame` through `r` into a fresh 64 × 64 target and read the pixels back.
+ fn render_frame(r: &mut Renderer, device: &wgpu::Device, queue: &wgpu::Queue, frame: &Frame, with_depth: bool) -> Vec<u8> {
+ const SIZE: u32 = 64;
+ let depth = crate::depth_format(device, true);
+ let format = wgpu::TextureFormat::Rgba8Unorm;
+ let texture = |format, usage| {
+ device.create_texture(&wgpu::TextureDescriptor {
+ label: None,
+ size: wgpu::Extent3d { width: SIZE, height: SIZE, depth_or_array_layers: 1 },
+ mip_level_count: 1,
+ sample_count: 1,
+ dimension: wgpu::TextureDimension::D2,
+ format,
+ usage,
+ view_formats: &[],
+ })
+ };
+ let color = texture(format, wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC);
+ let color_view = color.create_view(&Default::default());
+ let depth_tex = with_depth.then(|| texture(depth, wgpu::TextureUsages::RENDER_ATTACHMENT));
+ let depth_view = depth_tex.as_ref().map(|t| t.create_view(&Default::default()));
+ let mut encoder = device.create_command_encoder(&Default::default());
+ r.prepare(device, queue, &mut encoder, frame);
+ {
+ let mut pass = encoder
+ .begin_render_pass(&wgpu::RenderPassDescriptor {
+ label: None,
+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+ view: &color_view,
+ depth_slice: None,
+ resolve_target: None,
+ ops: wgpu::Operations { load: wgpu::LoadOp::Clear(wgpu::Color::WHITE), store: wgpu::StoreOp::Store },
+ })],
+ depth_stencil_attachment: depth_view.as_ref().map(|view| wgpu::RenderPassDepthStencilAttachment {
+ view,
+ depth_ops: Some(wgpu::Operations {
+ load: wgpu::LoadOp::Clear(far_depth(reversed_depth(Some(depth)))),
+ store: wgpu::StoreOp::Store,
+ }),
+ stencil_ops: depth
+ .has_stencil_aspect()
+ .then_some(wgpu::Operations { load: wgpu::LoadOp::Clear(0), store: wgpu::StoreOp::Store }),
+ }),
+ timestamp_writes: None,
+ occlusion_query_set: None,
+ multiview_mask: None,
+ })
+ .forget_lifetime();
+ r.paint(frame, &mut pass, [0.0, 0.0, SIZE as f32, SIZE as f32]);
+ }
+ let read = device.create_buffer(&wgpu::BufferDescriptor {
+ label: None,
+ size: u64::from(SIZE * SIZE * 4),
+ usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+ mapped_at_creation: false,
+ });
+ encoder.copy_texture_to_buffer(
+ color.as_image_copy(),
+ wgpu::TexelCopyBufferInfo {
+ buffer: &read,
+ layout: wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(SIZE * 4), rows_per_image: Some(SIZE) },
+ },
+ wgpu::Extent3d { width: SIZE, height: SIZE, depth_or_array_layers: 1 },
+ );
+ queue.submit([encoder.finish()]);
+ read.slice(..).map_async(wgpu::MapMode::Read, |_| {});
+ device.poll(wgpu::PollType::wait_indefinitely()).ok();
+ read.slice(..).get_mapped_range().map(|b| b.to_vec()).unwrap_or_default()
+ }
+
+ /// A frame showing `scene` at a fixed view, `ssaa` times the viewport's pixels each way.
+ fn test_frame(scene: GpuScene, ssaa: f32) -> Frame {
+ const SIZE: u32 = 64;
+ let none = || Arc::new(Mutex::new(None));
+ Frame {
+ product: false,
+ key: 1,
+ slot: Arc::new(Mutex::new(Some(scene))),
+ sketch_key: 0,
+ sketch_slot: none(),
+ hl_key: 0,
+ hl_slot: none(),
+ pv_key: 0,
+ pv_slot: none(),
+ pv_hide: false,
+ view_proj: [[0.1, 0.0, 0.0, 0.0], [0.0, 0.1, 0.0, 0.0], [0.0, 0.0, -0.01, 0.0], [0.0, 0.0, 0.5, 1.0]],
+ back: [0.0, 0.0, 1.0],
+ size_px: [SIZE as f32; 2],
+ clip: [0.0; 4],
+ cap: [0.0; 4],
+ images: Vec::new(),
+ analysis: [0.0; 8],
+ analysis_colors: [0.0; 36],
+ access: None,
+ outline: false,
+ eye: [0.0, 0.0, 100.0, 0.0],
+ ao_radius: 0.0,
+ ssaa,
+ }
+ }
+
+ /// A frame of opaque triangles at the fixed view.
+ fn test_scene() -> GpuScene {
+ let mut scene = GpuScene::default();
+ scene.tri([-5.0, -5.0, 0.0], [0.0, 0.0, 1.0], [255, 0, 0, 255]);
+ scene.tri([5.0, -5.0, 0.0], [0.0, 0.0, 1.0], [255, 0, 0, 255]);
+ scene.tri([0.0, 5.0, 0.0], [0.0, 0.0, 1.0], [255, 0, 0, 255]);
+ scene
+ }
+
+ /// A still view shows the picture it drew last: a reused frame (whose filtered picture is
+ /// cached once) draws the same pixels as the frame before it, and changing the camera draws
+ /// again rather than keeping the cached picture.
+ #[test]
+ fn a_still_frame_blits_the_cached_picture() {
+ let Some((_, device, queue)) = crate::open_headless().ok() else { return };
+ let depth = crate::depth_format(&device, true);
+ let format = wgpu::TextureFormat::Rgba8Unorm;
+ let mut r = Renderer::new(&device, GpuTarget { format, depth: Some(depth), samples: 1, tess: false }, None);
+ // Supersampled: the picture is drawn into a texture, so it can be cached.
+ let mut frame = test_frame(test_scene(), 2.0);
+ let first = render_frame(&mut r, &device, &queue, &frame, true);
+ assert!(r.ss_ready && r.ss_scaled, "the first frame is drawn supersampled");
+ let again = render_frame(&mut r, &device, &queue, &frame, true);
+ assert!(r.cached.is_some(), "the still frame's filtered picture is cached");
+ // The cached picture goes through one more 8-bit texture than the direct filter.
+ assert!(first.iter().zip(&again).all(|(a, b)| a.abs_diff(*b) <= 1), "a reused frame draws the same picture");
+ // A moved camera is a new picture: the cache is dropped and the scene drawn again.
+ frame.view_proj[3][0] += 0.5;
+ let moved = render_frame(&mut r, &device, &queue, &frame, true);
+ assert!(r.cached.is_none(), "a changed view cannot show the cached picture");
+ assert_ne!(first, moved, "the changed view is drawn");
+ }
+
+ /// A window pass of another kind (one sample, no depth) shows the same picture: the scene is
+ /// drawn offscreen with its own depth and MSAA, then blitted into the window's pass.
+ #[test]
+ fn a_split_window_target_blits_the_offscreen_scene() {
+ 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 };
+ let window_target = GpuTarget { format, depth: None, samples: 1, tess: false };
+ let mut direct = Renderer::new(&device, scene_target, None);
+ let mut split = Renderer::with_window_target(&device, scene_target, window_target, None);
+ // Each renderer takes the scene out of its slot: a frame of its own for each.
+ let drawn = render_frame(&mut direct, &device, &queue, &test_frame(test_scene(), 1.0), true);
+ let shown = render_frame(&mut split, &device, &queue, &test_frame(test_scene(), 1.0), false);
+ assert!(split.ss_ready, "the split frame is drawn offscreen");
+ let max = drawn.iter().zip(&shown).map(|(a, b)| a.abs_diff(*b)).max().unwrap_or(0);
+ assert!(max <= 1, "the blitted picture matches the direct one (max difference {max})");
+ }
+
/// Two see-through squares, one at z = 5 (near) and one at z = -5, in `near` and `far`
/// colours, given near first or far first.
fn two_layers(near: [u8; 4], far: [u8; 4], near_first: bool) -> GpuScene {
diff --git a/crates/ui-egui/src/gpu.rs b/crates/ui-egui/src/gpu.rs
index e53fe0a081..bdb3af59fe 100644
--- a/crates/ui-egui/src/gpu.rs
+++ b/crates/ui-egui/src/gpu.rs
@@ -15,15 +15,17 @@ pub use solidcraft_gpu::view::{
/// A frame of the viewport as an egui paint callback.
pub struct ViewportCallback(pub Frame);
-/// Create the pipelines. Call once with the app's render state and its depth/stencil/MSAA
-/// settings. Without a stencil the section cap does not hide the inside of cut bodies. Without
-/// `gpu_meshing` (safe mode) bodies are meshed on the CPU.
-pub fn install(rs: &egui_wgpu::RenderState, depth_bits: u8, stencil_bits: u8, samples: u32, gpu_meshing: bool) -> GpuTarget {
+/// Create the pipelines. Call once with the app's render state, the scene target's depth/stencil/
+/// MSAA settings, and the target of the pass the picture is shown in. Without a stencil the
+/// section cap does not hide the inside of cut bodies. Without `gpu_meshing` (safe mode) bodies
+/// are meshed on the CPU. When the two targets differ, the scene is drawn offscreen and blitted.
+pub fn install(rs: &egui_wgpu::RenderState, scene: GpuTarget, window: GpuTarget, gpu_meshing: bool) -> GpuTarget {
let tess = if gpu_meshing { solidcraft_gpu::view::tessellation(&rs.adapter, &rs.device, &rs.queue, solidcraft_gpu::SHADER) } else { None };
- let t = GpuTarget { format: rs.target_format, depth: egui_wgpu::depth_format_from_bits(depth_bits, stencil_bits), samples, tess: tess.is_some() };
- let res = Renderer::new(&rs.device, t, tess);
+ let scene = GpuTarget { tess: tess.is_some(), ..scene };
+ let window = GpuTarget { tess: tess.is_some(), ..window };
+ let res = Renderer::with_window_target(&rs.device, scene, window, tess);
rs.renderer.write().callback_resources.insert(res);
- t
+ scene
}
/// Draw this process's headless pictures (`ui.render`, the agent's view image, thumbnails of
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index a1e4f73e48..b6c7a4d428 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -632,14 +632,36 @@ impl SolveApp {
/// Draw the viewport on the GPU (eframe's wgpu render state, with the app's depth and
/// stencil buffer bits and MSAA sample count). Without it the viewport renders on the CPU.
+ /// The scene is drawn in a pass of the same kind as the window's.
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.cpu_meshing));
+ let target = crate::gpu::GpuTarget {
+ format: rs.target_format,
+ depth: egui_wgpu::depth_format_from_bits(depth_bits, stencil_bits),
+ samples: samples.max(1),
+ tess: false,
+ };
+ self.set_wgpu_targets(rs, target, target);
+ }
+
+ /// Draw the viewport on the GPU with the scene drawn offscreen: `depth_bits`/`stencil_bits`
+ /// and `samples` are the scene's, while the window's pass (egui's) has no depth and one
+ /// sample. The scene keeps its depth and anti-aliasing; the UI pass pays for neither.
+ pub fn set_wgpu_split(&mut self, rs: &egui_wgpu::RenderState, depth_bits: u8, stencil_bits: u8, samples: u32) {
+ let scene = crate::gpu::GpuTarget {
+ format: rs.target_format,
+ depth: egui_wgpu::depth_format_from_bits(depth_bits, stencil_bits),
+ samples: samples.max(1),
+ tess: false,
+ };
+ let window = crate::gpu::GpuTarget { format: rs.target_format, depth: None, samples: 1, tess: false };
+ self.set_wgpu_targets(rs, scene, window);
+ }
+
+ fn set_wgpu_targets(&mut self, rs: &egui_wgpu::RenderState, scene: crate::gpu::GpuTarget, window: crate::gpu::GpuTarget) {
+ self.viewport.gpu = Some(gpu::install(rs, scene, window, !self.cpu_meshing));
render_workspace::invalidate_scene(self);
- self.render_workspace.host = match render_workspace::host_executor(
- rs.device.limits().max_texture_dimension_2d,
- self.viewport.gpu.is_some_and(|g| g.depth.is_some()),
- samples.max(1),
- ) {
+ let (samples, has_depth) = self.viewport.gpu.map_or((1, false), |g| (g.samples.max(1), g.depth.is_some()));
+ self.render_workspace.host = match render_workspace::host_executor(rs.device.limits().max_texture_dimension_2d, has_depth, samples) {
Ok(executor) => Some(executor),
Err(error) => {
self.set_status(error, true);