SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Optional supersampling (SSAA) for the viewport, adaptive and capped to the texture limit (#1288) (#1321)
bherbruck6f115ad7409a
diff --git a/assets/locales/de.json b/assets/locales/de.jsonindex 946872cefe..93569ee2e2 100644--- a/assets/locales/de.json+++ b/assets/locales/de.json@@ -49,6 +49,10 @@"ui.animation": "Animation","ui.animation_speed": "Animationsgeschwindigkeit","ui.anti_aliasing": "Kantenglättung",+ "ui.supersampling": "Supersampling (SSAA)",+ "ui.supersampling_off": "Aus (1×)",+ "ui.supersampling_adaptive": "Nur bei ruhender Ansicht",+ "settings.supersampling_note": "Zeichnet die Ansicht in höherer Auflösung und rechnet sie herunter: glattere Kanten, Linien und Raster auf Bildschirmen unter 4K. Kostet GPU-Zeit: etwa 2,25-mal so viele Pixel bei 1,5× und 4-mal bei 2×.","ui.display_quality": "Darstellungsqualität","ui.display_quality_coarse": "Grob","ui.display_quality_normal": "Normal",diff --git a/assets/locales/en.json b/assets/locales/en.jsonindex c06fe8c48e..ef1f8c8959 100644--- a/assets/locales/en.json+++ b/assets/locales/en.json@@ -327,6 +327,10 @@"ui.animation": "Animation","ui.animation_speed": "Animation speed","ui.anti_aliasing": "Anti-aliasing",+ "ui.supersampling": "Supersampling (SSAA)",+ "ui.supersampling_off": "Off (1×)",+ "ui.supersampling_adaptive": "Only when the view is still",+ "settings.supersampling_note": "Draws the view at a higher resolution and filters it down: smoother edges, lines and grid on screens below 4K. It costs GPU time: about 2.25× the pixels at 1.5× and 4× at 2×.","ui.display_quality": "Display quality","ui.display_quality_coarse": "Coarse","ui.display_quality_normal": "Normal",diff --git a/assets/locales/ja.json b/assets/locales/ja.jsonindex db1df53bde..c48544eced 100644--- a/assets/locales/ja.json+++ b/assets/locales/ja.json@@ -327,6 +327,10 @@"ui.animation": "アニメーション","ui.animation_speed": "アニメーション速度","ui.anti_aliasing": "アンチエイリアス",+ "ui.supersampling": "スーパーサンプリング (SSAA)",+ "ui.supersampling_off": "オフ (1×)",+ "ui.supersampling_adaptive": "ビューが静止しているときのみ",+ "settings.supersampling_note": "ビューを高い解像度で描画してから縮小します。4K 未満の画面でエッジ、線、グリッドが滑らかになります。GPU の負荷が増えます(1.5× で約 2.25 倍、2× で 4 倍のピクセル)。","ui.display_quality": "表示品質","ui.display_quality_coarse": "粗い","ui.display_quality_normal": "標準",diff --git a/assets/locales/ko.json b/assets/locales/ko.jsonindex b5e11d4c4a..4208a77628 100644--- a/assets/locales/ko.json+++ b/assets/locales/ko.json@@ -49,6 +49,10 @@"ui.animation": "애니메이션","ui.animation_speed": "애니메이션 속도","ui.anti_aliasing": "안티앨리어싱",+ "ui.supersampling": "슈퍼샘플링 (SSAA)",+ "ui.supersampling_off": "끔 (1×)",+ "ui.supersampling_adaptive": "뷰가 멈춰 있을 때만",+ "settings.supersampling_note": "뷰를 더 높은 해상도로 그린 뒤 축소합니다. 4K 미만 화면에서 모서리, 선, 그리드가 더 매끄러워집니다. GPU 시간이 듭니다: 1.5×에서 약 2.25배, 2×에서 4배의 픽셀.","ui.display_quality": "표시 품질","ui.display_quality_coarse": "거침","ui.display_quality_normal": "보통",diff --git a/assets/locales/zh.json b/assets/locales/zh.jsonindex c7c0ff28c6..17b3ce8f6c 100644--- a/assets/locales/zh.json+++ b/assets/locales/zh.json@@ -326,6 +326,10 @@"ui.animation": "动画","ui.animation_speed": "动画速度","ui.anti_aliasing": "抗锯齿",+ "ui.supersampling": "超级采样 (SSAA)",+ "ui.supersampling_off": "关 (1×)",+ "ui.supersampling_adaptive": "仅在视图静止时",+ "settings.supersampling_note": "以更高分辨率绘制视图再缩小:在低于 4K 的屏幕上边、线和网格更平滑。会消耗 GPU 时间:1.5× 时约 2.25 倍像素,2× 时 4 倍。","ui.display_quality": "显示质量","ui.display_quality_coarse": "粗糙","ui.display_quality_normal": "标准",diff --git a/crates/ui-egui/src/gpu.rs b/crates/ui-egui/src/gpu.rsindex dfab108ffb..842155c49c 100644--- a/crates/ui-egui/src/gpu.rs+++ b/crates/ui-egui/src/gpu.rs@@ -243,6 +243,9 @@ pub struct ViewportCallback {/// Eye position and 1 for a perspective camera (0: orthographic), for the section cap's depth/// and the depth bias.pub eye: [f32; 4],+ /// Supersampling (#1288): draw the frame this many times the viewport's pixels in each+ /// direction and filter it down (1: off).+ pub ssaa: f32,}/// Heights of the model seen from a direction (an orthographic depth map): a point is reachable@@ -474,8 +477,77 @@ struct Resources {/// The accessibility depth map (a 1 × 1 stand-in when there is none) and its version.access_bind: wgpu::BindGroup,access_version: u64,+ /// The target the pipelines draw into (format, depth, samples): a supersampled frame is+ /// drawn into textures of the same kind.+ target: 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,+ ss_bgl: wgpu::BindGroupLayout,+ /// The supersampled frame's textures, kept while its size stays.+ ss: Option<Supersampled>,+ /// This frame was drawn supersampled (in `prepare`): `paint` only filters it down.+ ss_ready: bool,}+/// A supersampled frame: the scene drawn at a multiple of the viewport's pixels.+struct Supersampled {+ size: [u32; 2],+ /// Drawn into (multisampled with the viewport's MSAA).+ color: wgpu::TextureView,+ /// The resolved colour (when `color` is multisampled).+ resolve: Option<wgpu::TextureView>,+ depth: Option<wgpu::TextureView>,+ /// The single-sampled colour, for the filter.+ bind: wgpu::BindGroup,+}++/// Most memory (bytes) a supersampled frame's colour and depth may take.+const SS_BUDGET: u64 = 384 << 20;++/// 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.+pub(crate) fn supersampled_size(size: [f32; 2], factor: f32, max_side: u32, samples: u32) -> Option<[u32; 2]> {+ let [w, h] = size;+ if !(w >= 1.0 && h >= 1.0 && factor.is_finite() && factor > 1.0) {+ return None;+ }+ 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 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 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#"+@group(0) @binding(0) var src: texture_2d<f32>;+@group(0) @binding(1) var smp: sampler;+struct O { @builtin(position) pos: vec4<f32>, @location(0) uv: vec2<f32> };+@vertex+fn vs(@builtin(vertex_index) i: u32) -> O {+ let x = f32((i << 1u) & 2u);+ let y = f32(i & 2u);+ var o: O;+ o.pos = vec4<f32>(x * 2.0 - 1.0, 1.0 - y * 2.0, 0.0, 1.0);+ o.uv = vec2<f32>(x, y);+ return o;+}+@fragment+fn fs(i: O) -> @location(0) vec4<f32> {+ let d = vec2<f32>(dpdx(i.uv.x), dpdy(i.uv.y)) * 0.25;+ let a = textureSampleLevel(src, smp, i.uv + vec2<f32>(-d.x, -d.y), 0.0);+ let b = textureSampleLevel(src, smp, i.uv + vec2<f32>(d.x, -d.y), 0.0);+ let c = textureSampleLevel(src, smp, i.uv + vec2<f32>(-d.x, d.y), 0.0);+ let e = textureSampleLevel(src, smp, i.uv + vec2<f32>(d.x, d.y), 0.0);+ return (a + b + c + e) * 0.25;+}+"#;+fn access_texture(device: &wgpu::Device, queue: Option<&wgpu::Queue>, bgl: &wgpu::BindGroupLayout, size: u32, depth: &[f32]) -> wgpu::BindGroup {let extent = wgpu::Extent3d { width: size.max(1), height: size.max(1), depth_or_array_layers: 1 };let tex = device.create_texture(&wgpu::TextureDescriptor {@@ -766,7 +838,63 @@ impl Resources {min_filter: wgpu::FilterMode::Linear,..Default::default()});+ let ss_module =+ device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("sc_ssaa"), source: wgpu::ShaderSource::Wgsl(SS_SHADER.into()) });+ let ss_bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {+ label: Some("sc_ssaa"),+ entries: &[+ wgpu::BindGroupLayoutEntry {+ binding: 0,+ visibility: wgpu::ShaderStages::FRAGMENT,+ ty: wgpu::BindingType::Texture {+ sample_type: wgpu::TextureSampleType::Float { filterable: true },+ view_dimension: wgpu::TextureViewDimension::D2,+ multisampled: false,+ },+ count: None,+ },+ wgpu::BindGroupLayoutEntry {+ binding: 1,+ visibility: wgpu::ShaderStages::FRAGMENT,+ ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),+ count: None,+ },+ ],+ });+ let ss_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {+ label: Some("sc_ssaa"),+ bind_group_layouts: &[Some(&ss_bgl)],+ immediate_size: 0,+ });+ // 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 ss_blit = 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 },+ fragment: Some(wgpu::FragmentState {+ module: &ss_module,+ entry_point: Some("fs"),+ targets: &[Some(wgpu::ColorTargetState {+ format: t.format,+ blend: Some(wgpu::BlendState::PREMULTIPLIED_ALPHA_BLENDING),+ write_mask: wgpu::ColorWrites::ALL,+ })],+ compilation_options: Default::default(),+ }),+ multiview_mask: None,+ cache: None,+ });Resources {+ target: t,+ max_texture: device.limits().max_texture_dimension_2d,+ ss_blit,+ ss_bgl,+ ss: None,+ ss_ready: false,image,image_bgl,sampler,@@ -998,6 +1126,7 @@ impl egui_wgpu::CallbackTrait for ViewportCallback {res.quads.push((img.id, b));}}+ res.ss_ready = self.ssaa > 1.0 && res.supersample(device, encoder, self);Vec::new()}@@ -1008,6 +1137,23 @@ impl egui_wgpu::CallbackTrait for ViewportCallback {return;}pass.set_viewport(vp.left_px as f32, vp.top_px as f32, vp.width_px as f32, vp.height_px as f32, 0.0, 1.0);+ // Drawn supersampled in `prepare`: filter it down into the viewport.+ if res.ss_ready+ && let Some(ss) = &res.ss+ {+ pass.set_pipeline(&res.ss_blit);+ pass.set_bind_group(0, &ss.bind, &[]);+ pass.draw(0..3, 0..1);+ return;+ }+ res.draw(self, pass);+ }+}++impl Resources {+ /// Draw the frame's scenes into `pass` (its viewport already set).+ fn draw(&self, cb: &ViewportCallback, pass: &mut wgpu::RenderPass<'static>) {+ let res = self;pass.set_bind_group(0, &res.bind, &[]);let tris = |pass: &mut wgpu::RenderPass<'static>, p: &wgpu::RenderPipeline, b: &Option<Batch>| {if let Some(b) = b {@@ -1028,7 +1174,7 @@ impl egui_wgpu::CallbackTrait for ViewportCallback {}};let (m, sk, h, pv) =- if self.product { (&res.product, &res.empty, &res.empty, &res.empty) } else { (&res.model, &res.sketch, &res.highlight, &res.preview) };+ if cb.product { (&res.product, &res.empty, &res.empty, &res.empty) } else { (&res.model, &res.sketch, &res.highlight, &res.preview) };lines(pass, &res.overlay, &m.under);lines(pass, &res.overlay, &sk.under);pass.set_bind_group(1, &res.access_bind, &[]);@@ -1041,7 +1187,7 @@ impl egui_wgpu::CallbackTrait for ViewportCallback {pass.draw_indexed(0..d.mesh.index_count, 0, 0..1);}};- let sectioned = self.clip[..3].iter().map(|c| c * c).sum::<f32>() > 0.25;+ let sectioned = cb.clip[..3].iter().map(|c| c * c).sum::<f32>() > 0.25;match (res.tri_cut.as_ref().filter(|_| sectioned), res.tri_cut_planned.as_ref()) {(Some((mark, cap)), Some((mark_planned, cap_planned))) => {pass.set_stencil_reference(1);@@ -1067,7 +1213,7 @@ impl egui_wgpu::CallbackTrait for ViewportCallback {lines(pass, &res.line, &pv.lines);lines(pass, &res.line, &h.lines);lines(pass, &res.guide_line, &h.guide_lines);- for (id, q) in res.quads.iter().filter(|_| !self.product) {+ for (id, q) in res.quads.iter().filter(|_| !cb.product) {if let Some((_, bind)) = res.textures.get(id) {pass.set_pipeline(&res.image);pass.set_bind_group(1, bind, &[]);@@ -1091,6 +1237,83 @@ impl egui_wgpu::CallbackTrait for ViewportCallback {}}+impl Resources {+ /// 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.+ fn supersample(&mut self, device: &wgpu::Device, encoder: &mut wgpu::CommandEncoder, cb: &ViewportCallback) -> bool {+ let Some(size) = supersampled_size(cb.size_px, cb.ssaa, self.max_texture, self.target.samples) else {+ self.ss = None;+ return false;+ };+ if self.ss.as_ref().is_none_or(|ss| ss.size != size) {+ self.ss = Some(self.supersampled(device, size));+ }+ let Some(ss) = &self.ss else { return false };+ let depth_format = self.target.depth;+ let mut pass = encoder+ .begin_render_pass(&wgpu::RenderPassDescriptor {+ label: Some("sc_ssaa"),+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {+ view: &ss.color,+ depth_slice: None,+ resolve_target: ss.resolve.as_ref(),+ ops: wgpu::Operations { load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT), store: wgpu::StoreOp::Store },+ })],+ depth_stencil_attachment: ss.depth.as_ref().map(|view| wgpu::RenderPassDepthStencilAttachment {+ view,+ depth_ops: Some(wgpu::Operations { load: wgpu::LoadOp::Clear(1.0), store: wgpu::StoreOp::Discard }),+ stencil_ops: depth_format+ .filter(|f| f.has_stencil_aspect())+ .map(|_| wgpu::Operations { load: wgpu::LoadOp::Clear(0), store: wgpu::StoreOp::Discard }),+ }),+ timestamp_writes: None,+ occlusion_query_set: None,+ multiview_mask: None,+ })+ .forget_lifetime();+ pass.set_viewport(0.0, 0.0, size[0] as f32, size[1] as f32, 0.0, 1.0);+ self.draw(cb, &mut pass);+ true+ }++ /// Textures for a supersampled frame of `size` pixels.+ fn supersampled(&self, device: &wgpu::Device, size: [u32; 2]) -> Supersampled {+ let t = self.target;+ let texture = |label: &str, format: wgpu::TextureFormat, samples: u32, usage: wgpu::TextureUsages| {+ device+ .create_texture(&wgpu::TextureDescriptor {+ label: Some(label),+ size: wgpu::Extent3d { width: size[0], height: size[1], depth_or_array_layers: 1 },+ mip_level_count: 1,+ sample_count: samples,+ dimension: wgpu::TextureDimension::D2,+ format,+ usage,+ view_formats: &[],+ })+ .create_view(&Default::default())+ };+ let samples = t.samples.max(1);+ let sampled = wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING;+ let (color, resolve) = if samples > 1 {+ (texture("sc_ssaa_ms", t.format, samples, wgpu::TextureUsages::RENDER_ATTACHMENT), Some(texture("sc_ssaa", t.format, 1, sampled)))+ } else {+ (texture("sc_ssaa", t.format, 1, sampled), None)+ };+ let depth = t.depth.map(|f| texture("sc_ssaa_depth", f, samples, wgpu::TextureUsages::RENDER_ATTACHMENT));+ let bind = device.create_bind_group(&wgpu::BindGroupDescriptor {+ label: Some("sc_ssaa"),+ layout: &self.ss_bgl,+ entries: &[+ wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(resolve.as_ref().unwrap_or(&color)) },+ wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::Sampler(&self.sampler) },+ ],+ });+ Supersampled { size, color, resolve, depth, bind }+ }+}+/// A device of its own for an offscreen render or check (`None` without a GPU adapter).#[cfg(all(test, not(target_arch = "wasm32")))]fn offscreen_device() -> Option<(wgpu::Adapter, wgpu::Device, wgpu::Queue)> {@@ -1132,7 +1355,15 @@ pub(crate) fn render_offscreen(analysis: [f32; 8],colors: [f32; 36],) -> Option<Vec<u8>> {- offscreen(scene, highlight, view_proj, back, eye, size, Offscreen { tess, product: false, srgb: false, analysis, analysis_colors: colors })+ offscreen(+ scene,+ highlight,+ view_proj,+ back,+ eye,+ size,+ Offscreen { tess, product: false, srgb: false, analysis, analysis_colors: colors, ssaa: 1.0 },+ )}#[cfg(all(test, not(target_arch = "wasm32")))]@@ -1144,7 +1375,15 @@ pub(crate) fn render_product_offscreen(size: u32,srgb: bool,) -> Option<Vec<u8>> {- offscreen(scene, None, view_proj, back, eye, size, Offscreen { tess: None, product: true, srgb, analysis: [0.0; 8], analysis_colors: [0.0; 36] })+ offscreen(+ scene,+ None,+ view_proj,+ back,+ eye,+ size,+ Offscreen { tess: None, product: true, srgb, analysis: [0.0; 8], analysis_colors: [0.0; 36], ssaa: 1.0 },+ )}#[cfg(all(test, not(target_arch = "wasm32")))]@@ -1154,6 +1393,28 @@ struct Offscreen<'a> {srgb: bool,analysis: [f32; 8],analysis_colors: [f32; 36],+ ssaa: f32,+}++/// [`render_offscreen`] of a scene supersampled `ssaa` times (1: off).+#[cfg(all(test, not(target_arch = "wasm32")))]+pub(crate) fn render_offscreen_ssaa(+ scene: GpuScene,+ view_proj: [[f32; 4]; 4],+ back: [f32; 3],+ eye: [f32; 4],+ size: u32,+ ssaa: f32,+) -> Option<Vec<u8>> {+ offscreen(+ scene,+ None,+ view_proj,+ back,+ eye,+ size,+ Offscreen { tess: None, product: false, srgb: false, analysis: [0.0; 8], analysis_colors: [0.0; 36], ssaa },+ )}#[cfg(all(test, not(target_arch = "wasm32")))]@@ -1166,7 +1427,7 @@ fn offscreen(size: u32,options: Offscreen<'_>,) -> Option<Vec<u8>> {- let Offscreen { tess, product, srgb, analysis, analysis_colors } = options;+ let Offscreen { tess, product, srgb, analysis, analysis_colors, ssaa } = options;let (adapter, device, queue) = offscreen_device()?;eprintln!("offscreen adapter: {:?}", adapter.get_info().backend);let format = if srgb { wgpu::TextureFormat::Rgba8UnormSrgb } else { wgpu::TextureFormat::Rgba8Unorm };@@ -1197,6 +1458,7 @@ fn offscreen(access: None,outline: false,eye,+ ssaa,};let texture = |format, usage| {device.create_texture(&wgpu::TextureDescriptor {diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rsindex 6a6bc5f1f1..8b8019616a 100644--- a/crates/ui-egui/src/prefs.rs+++ b/crates/ui-egui/src/prefs.rs@@ -205,6 +205,8 @@ 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];+/// Supersampling factors (#1288): off, 1.5× and 2× the viewport's pixels each way.+pub const SUPERSAMPLING: [f32; 3] = [1.0, 1.5, 2.0];/// Original view navigators, independent of the mouse navigation preset.#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]@@ -251,6 +253,11 @@ pub struct Prefs {/// How finely the viewport tessellates curved faces and edges: `coarse`, `normal`, `fine` or/// `ultra` (#1287). Only the display plan the viewport draws; never the design or exports.pub display_quality: String,+ /// Supersampling (#1288): the view drawn at this many times its pixels each way and filtered+ /// down (1, 1.5 or 2; 1 is off).+ pub supersampling: f32,+ /// Supersample only while the view holds still (full speed while orbiting).+ pub supersampling_adaptive: bool,/// Decimals shown for lengths and angles.pub length_decimals: u8,pub angle_decimals: u8,@@ -331,6 +338,8 @@ impl Default for Prefs {space_mouse_speed: 1.0,msaa: 4,display_quality: "normal".into(),+ supersampling: 1.0,+ supersampling_adaptive: true,length_decimals: 2,angle_decimals: 1,theme: "dark".into(),@@ -472,6 +481,8 @@ fn defaults(app: &mut SolveApp, page: usize) {let msaa = p.msaa != d.msaa;p.msaa = d.msaa;p.display_quality = d.display_quality;+ p.supersampling = d.supersampling;+ p.supersampling_adaptive = d.supersampling_adaptive;p.color_vision = d.color_vision;app.ui.visual_style = 0;app.ui.show_grid = true;@@ -1118,6 +1129,19 @@ fn page(app: &mut SolveApp, ui: &mut egui::Ui, t: &Tokens) {}ui.end_row();note(ui, app.tr("settings.display_quality_note"));+ ui.label(app.tr("ui.supersampling"));+ let ss_label = |f: f32| if f > 1.0 { format!("{f}×") } else { crate::i18n::tr("ui.supersampling_off").to_string() };+ let adaptive = app.tr("ui.supersampling_adaptive").to_string();+ ui.horizontal(|ui| {+ egui::ComboBox::from_id_salt("pref_ssaa").selected_text(ss_label(app.preferences.supersampling)).show_ui(ui, |ui| {+ for f in SUPERSAMPLING {+ ui.selectable_value(&mut app.preferences.supersampling, f, ss_label(f));+ }+ });+ ui.add_enabled(app.preferences.supersampling > 1.0, egui::Checkbox::new(&mut app.preferences.supersampling_adaptive, adaptive));+ });+ ui.end_row();+ note(ui, app.tr("settings.supersampling_note"));ui.label(crate::i18n::tr_label("Renderer"));ui.label(match (&app.viewport.gpu, &app.help.gpu) {(Some(_), Some(g)) => format!("GPU: {g}"),@@ -1332,6 +1356,9 @@ pub fn set(app: &mut SolveApp, p: &serde_json::Value) -> Result<serde_json::Valuif solidcraft_engine::doc::display_quality::DisplayQuality::parse(&new.display_quality).is_none() {return Err("`display_quality` must be coarse, normal, fine or ultra".into());}+ if !SUPERSAMPLING.contains(&new.supersampling) {+ return Err("`supersampling` must be 1 (off), 1.5 or 2".into());+ }if MiddleDoubleClick::parse(&new.middle_double_click).is_none() {return Err("`middle_double_click` must be home, fit or off".into());}@@ -1368,6 +1395,20 @@ mod tests {assert_eq!(app.preferences.display_quality, "normal");}+ /// Supersampling (#1288): off by default, adaptive, set by factor and checked.+ #[test]+ fn supersampling_is_off_by_default_and_checked() {+ use serde_json::json;+ let mut app = crate::SolveApp::new(solidcraft_engine::Session::default(), crate::Services::default());+ assert_eq!((app.preferences.supersampling, app.preferences.supersampling_adaptive), (1.0, true));+ super::set(&mut app, &json!({"supersampling": 2.0})).unwrap();+ assert_eq!(app.preferences.supersampling, 2.0);+ assert!(super::set(&mut app, &json!({"supersampling": 3.0})).unwrap_err().contains("1 (off), 1.5 or 2"));+ super::set(&mut app, &json!({"supersampling": 1.5, "supersampling_adaptive": false})).unwrap();+ super::defaults(&mut app, super::PAGE_GRAPHICS);+ assert_eq!((app.preferences.supersampling, app.preferences.supersampling_adaptive), (1.0, true));+ }+#[test]fn a_value_this_version_does_not_understand_keeps_the_other_preferences() {use serde_json::json;diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rsindex 690a5c87c9..6045336c3d 100644--- a/crates/ui-egui/src/render_workspace.rs+++ b/crates/ui-egui/src/render_workspace.rs@@ -525,6 +525,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {access: None,outline: false,eye: [eye.x as f32, eye.y as f32, eye.z as f32, if camera.fov > 0.0 { 1.0 } else { 0.0 }],+ ssaa: 1.0,};ui.painter().add(egui_wgpu::Callback::new_paint_callback(rect, callback));Ok(())diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex 3f811d7b7c..d381e9263b 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -96,6 +96,9 @@ pub struct ViewportState {/// Spring toward the chosen orientation, including after the drag ends.pub(crate) orbit_snap: Option<OrbitSnap>,pub build_ms: f64,+ /// Adaptive supersampling (#1288): the view drawn last (its view-projection and pixels) and+ /// since when it has held still (app time, s).+ pub(crate) ss_view: (u64, f64),/// The right-click menu, open at this screen position.pub context_menu: Option<Pos2>,/// Select Other: its list, a press being held, and click cycling.@@ -331,6 +334,37 @@ fn body_faded(app: &SolveApp, b: &solidcraft_engine::doc::ModelBody, active_bodi}}+/// How many times the viewport's pixels to draw this frame each way (#1288; 1: off): the+/// preference, and with adaptive supersampling only once the view has held still for a moment,+/// so orbiting and zooming stay as quick as without it.+fn supersampling(app: &mut SolveApp, ctx: &egui::Context, view_proj: [[f32; 4]; 4], size_px: [f32; 2]) -> f32 {+ let factor = app.preferences.supersampling;+ if !(factor > 1.0) {+ return 1.0;+ }+ if !app.preferences.supersampling_adaptive {+ return factor;+ }+ let mut h = std::collections::hash_map::DefaultHasher::new();+ view_proj.iter().flatten().chain(&size_px).for_each(|x| x.to_bits().hash(&mut h));+ let view = h.finish();+ let now = ctx.input(|i| i.time);+ if view != app.viewport.ss_view.0 {+ app.viewport.ss_view = (view, now);+ }+ let still = now - app.viewport.ss_view.1;+ if still >= SS_SETTLE {+ factor+ } else {+ // Draw it supersampled once the view settles.+ ctx.request_repaint_after(std::time::Duration::from_secs_f64(SS_SETTLE - still + 0.01));+ 1.0+ }+}++/// How long the view holds still before adaptive supersampling draws it at full quality (s).+const SS_SETTLE: f64 = 0.25;+/// The display plan the model scene draws `b` from on the GPU, or `None` when its faces are built/// here from the reference mesh. Opaque shaded bodies (`opaque`: not faded, and no see-through/// body or face) are drawn from their plans where the device evaluates them; faded and@@ -2423,7 +2457,10 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {app.viewport.hl_key = hk;}let ppp = ui.ctx().pixels_per_point();+ let size_px = [rect.width() * ppp, rect.height() * ppp];+ let ssaa = supersampling(app, ui.ctx(), proj.vp.to_f32(), size_px);let cb = ViewportCallback {+ ssaa,product: false,key: app.viewport.key,slot: app.viewport.slot.clone(),@@ -2437,7 +2474,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {cap: t.section_cap.to_normalized_gamma_f32(),view_proj: proj.vp.to_f32(),back: proj.cam.back().to_f32(),- size_px: [rect.width() * ppp, rect.height() * ppp],+ size_px,images: crate::ref_images::gpu_images(app),analysis: analysis_uniform(app),analysis_colors: crate::gpu::analysis_colors(&t.analysis),@@ -3739,6 +3776,60 @@ mod tests {assert!(drawn > n / 20, "the model is drawn: {drawn} pixels");}+ /// Supersampling (#1288): the sample design drawn at 2× and filtered down shows the same+ /// model (the same pixels covered, give or take its outline) with smoothed edges: pixels part+ /// model, part background, which a single-sampled frame does not have. Skipped without a GPU+ /// adapter.+ #[cfg(not(target_arch = "wasm32"))]+ #[test]+ fn supersampling_draws_the_same_model_with_smooth_edges() {+ let mut s = solidcraft_engine::Session::default();+ s.run_script(&solidcraft_engine::sample::script()).unwrap();+ let mut app = SolveApp::new(s, crate::Services::default());+ app.viewport.no_pixels = true;+ app.fit_view();+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false });+ const SIZE: u32 = 256;+ let rect = Rect::from_min_size(Pos2::ZERO, vec2(SIZE as f32, SIZE as f32));+ let proj = projection(&app, rect);+ let e = proj.cam.eye().to_f32();+ let eye = [e[0], e[1], e[2], if proj.cam.fov > 0.0 { 1.0 } else { 0.0 }];+ let render =+ |ssaa: f32| crate::gpu::render_offscreen_ssaa(build_scene(&app).merged(), proj.vp.to_f32(), proj.cam.back().to_f32(), eye, SIZE, ssaa);+ let (Some(plain), Some(super2)) = (render(1.0), render(2.0)) else {+ eprintln!("skipping: no GPU adapter");+ return;+ };+ let covered = |img: &[u8]| img.chunks(4).filter(|p| p[..3] != [255, 255, 255]).count();+ let (a, b) = (covered(&plain), covered(&super2));+ assert!(a > 2000, "the model is drawn: {a} pixels");+ assert!((a as f64 - b as f64).abs() < a as f64 * 0.1, "same model: {a} vs {b} pixels covered");+ // Edge pixels against the white background: neither white nor any colour the plain frame+ // has, so blended. A count well above the plain frame's own.+ let palette: std::collections::HashSet<[u8; 3]> = plain.chunks(4).map(|p| [p[0], p[1], p[2]]).collect();+ let new_colours = super2.chunks(4).filter(|p| !palette.contains(&[p[0], p[1], p[2]])).count();+ assert!(new_colours > 100, "the supersampled frame blends its edges: {new_colours} new colours");+ }++ /// The supersampled frame stays within the device's largest texture (#869) and a memory+ /// budget, and is not drawn at all when that leaves too little to gain.+ #[test]+ fn supersampling_keeps_within_the_device_texture_limit() {+ use crate::gpu::supersampled_size;+ assert_eq!(supersampled_size([1920.0, 1080.0], 2.0, 16384, 1), Some([3840, 2160]));+ assert_eq!(supersampled_size([1920.0, 1080.0], 1.5, 16384, 1), Some([2880, 1620]));+ // A 4096 texture limit: a 2560 px wide view gets 1.6×.+ let [w, h] = supersampled_size([2560.0, 1440.0], 2.0, 4096, 1).unwrap();+ assert!((4095..=4096).contains(&w) && (2303..=2304).contains(&h), "{w} x {h}");+ // Under 1.25× is not worth it: drawn as usual.+ assert_eq!(supersampled_size([3840.0, 2160.0], 2.0, 4096, 1), None);+ assert_eq!(supersampled_size([1920.0, 1080.0], 1.0, 16384, 1), None);+ assert_eq!(supersampled_size([0.0, 1080.0], 2.0, 16384, 1), None);+ // 4× MSAA at 1440p: the memory budget caps it below 2×.+ let [w, h] = supersampled_size([2560.0, 1440.0], 2.0, 16384, 4).unwrap();+ assert!(w < 5120 && w as f32 >= 2560.0 * 1.25 && u64::from(w) * u64::from(h) * 32 <= 384 << 20, "{w} x {h}");+ }+/// A hovered face lights solidly over a body drawn from its display plan on the GPU: the/// highlight uses the plan's triangles, not the reference mesh's other triangulation of the/// same face, which fought the model at equal depth and shimmered in wedges. Every face of a