Viewport: fewer ambient occlusion samples while the view moves (#7165) (#7214)

* feat: Fewer ambient occlusion samples while the view moves (#7165)

- Draw AO with 8 samples while the view moves, 32 once it has held still for 0.25 s
- Share the settle tracking with adaptive supersampling and repaint when it settles
- ui.screenshot waits for the full-quality frame (at most half a second)
- Test the sample choice, the uniform slot, and ghosting at both counts

* fix: Set the AO sample count in the scale test frame

- scale_tests.rs, new on main, builds a gpu::Frame without ao_samples
- Use AO_SAMPLES, as the other still-frame builders do

---------

Co-authored-by: P'tite Tête <asso@ptitetete.com>
This commit is contained in:
P'tite TêteandP'tite Tête authored and GitHub committed 2026-10-28 15:05:34 +00:00
1 parent 8589cdfb84
commit a4d1b5b6a9
10 files changed
+219 -42

No files matched your search

+7 -4
View File
@@ -10,7 +10,7 @@ struct U {
acc_u: vec4<f32>, // accessibility map axes (xyz, offset)
acc_v: vec4<f32>,
eye: vec4<f32>, // eye position, w = 1 for perspective (0: orthographic, looking along -back)
ao: vec4<f32>, // radius in world units (zero: disabled)
ao: vec4<f32>, // x: radius in world units (zero: disabled), y: samples per pixel
// analysis colours (`theme::AnalysisColors`): draft positive, between, negative; reachable,
// blocked; curvature flat, middle, tight
ana_c: array<vec4<f32>, 8>,
@@ -333,9 +333,12 @@ fn occlusion(i: TOut) -> f32 {
// the buffer runs reversed). The map is cleared to its far plane either way, so a texel
// with nothing in it reads as 1 and the `d < 1.0` test below skips it.
let flip = reversed();
// Fewer samples while the view moves (#7165), spread over the same hemisphere. 32 is the
// still picture's count, `AO_SAMPLES` in view.rs.
let count = u32(clamp(u.ao.y, 1.0, 32.0));
var blocked = 0.0;
for (var j = 0u; j < 32u; j = j + 1u) {
let f = (f32(j) + 0.5) / 32.0;
for (var j = 0u; j < count; j = j + 1u) {
let f = (f32(j) + 0.5) / f32(count);
let angle = f32(j) * 2.39996323;
let direction = t * (cos(angle) * sqrt(f)) + b * (sin(angle) * sqrt(f)) + n * sqrt(1.0 - f);
let reach = radius * (0.2 + 0.8 * fract(f32(j) * 0.61803399 + 0.5));
@@ -356,7 +359,7 @@ fn occlusion(i: TOut) -> f32 {
blocked = blocked + smoothstep(0.005, 0.15, delta) * (1.0 - smoothstep(0.5, 1.0, delta));
}
}
return 1.0 - 0.85 * blocked / 32.0;
return 1.0 - 0.85 * blocked / f32(count);
}
/// How fast the normal turns across the pixel (per mm).
+1
View File
@@ -399,6 +399,7 @@ fn frame(scene: &Scene, cam: &Camera, [width, height]: [u32; 2], key: u64, acces
outline: true,
eye: [eye[0], eye[1], eye[2], if cam.fov > 0.0 { 1.0 } else { 0.0 }],
ao_radius: 0.0,
ao_samples: crate::view::AO_SAMPLES,
ssaa: 1.0,
hover_tint: [0.0; 3],
selection_tint: [0.0; 3],
+37 -1
View File
@@ -908,6 +908,14 @@ pub struct GpuImage {
/// Image vertex: position (3 × f32), uv (2 × f32), opacity (f32).
const IMG_SIZE: usize = 24;
/// Ambient occlusion samples per shaded pixel in a still picture (the shader's most).
pub const AO_SAMPLES: u32 = 32;
/// Ambient occlusion samples per shaded pixel while the view moves (#7165): a quarter of the
/// still picture's, on the same turned pattern, so orbiting costs less and shows no copies of
/// nearby parts (#4167).
pub const AO_SAMPLES_MOVING: u32 = 8;
/// Per-frame parameters.
pub struct Frame {
/// Product preview uses its own batches, retaining the Design viewport's uploads.
@@ -950,6 +958,9 @@ pub struct Frame {
pub eye: [f32; 4],
/// World-space occlusion radius; zero skips the depth prepass and all AO sampling.
pub ao_radius: f32,
/// Occlusion samples per shaded pixel: [`AO_SAMPLES`] for a still picture,
/// [`AO_SAMPLES_MOVING`] while the view moves (#7165).
pub ao_samples: u32,
/// Supersampling (#1288): draw the frame this many times the viewport's pixels in each
/// direction and filter it down (1: off). Under 1 the frame is drawn smaller and filtered up
/// (the product preview past its pixel budget, #1464).
@@ -3190,6 +3201,7 @@ fn frame_key(cb: &Frame) -> u64 {
cb.selection_tint.map(f32::to_bits).hash(&mut h);
cb.outline.hash(&mut h);
cb.ao_radius.to_bits().hash(&mut h);
cb.ao_samples.hash(&mut h);
cb.ssaa.to_bits().hash(&mut h);
for img in &cb.images {
img.id.hash(&mut h);
@@ -4000,7 +4012,7 @@ pub fn uniform_bytes(cb: &Frame, w: f32, h: f32, linear: bool, reversed: bool) -
None => v.extend([0.0; 8]),
}
v.extend(cb.eye);
v.extend([cb.ao_radius, 0.0, 0.0, 0.0]);
v.extend([cb.ao_radius, cb.ao_samples.clamp(1, AO_SAMPLES) as f32, 0.0, 0.0]);
v.extend(cb.analysis_colors);
v.extend([if reversed { 1.0 } else { 0.0 }, FACE_STEPS as f32, FACE_SLOPE, 0.0]);
v.extend([cb.hover_tint[0], cb.hover_tint[1], cb.hover_tint[2], 0.0]);
@@ -4166,6 +4178,25 @@ mod tests {
naga::valid::Validator::new(naga::valid::ValidationFlags::all(), naga::valid::Capabilities::empty()).validate(&module).unwrap();
}
/// The ambient occlusion sample count rides in the uniform's `ao.y`, beside the radius, kept
/// within the 1 to 32 samples the shader draws (#7165).
#[test]
fn ambient_occlusion_samples_follow_the_radius_in_the_uniform() {
let samples_sent = |samples: u32| {
let mut f = cached_frame();
f.ao_radius = 123.5;
f.ao_samples = samples;
let bytes = super::uniform_bytes(&f, 64.0, 64.0, false, false);
let v: Vec<f32> = bytes.as_chunks::<4>().0.iter().map(|c| f32::from_le_bytes(*c)).collect();
let radius = v.iter().position(|&x| x == 123.5).unwrap();
v[radius + 1]
};
assert_eq!(samples_sent(super::AO_SAMPLES), 32.0);
assert_eq!(samples_sent(super::AO_SAMPLES_MOVING), 8.0);
assert_eq!(samples_sent(0), 1.0, "at least one sample");
assert_eq!(samples_sent(1000), 32.0, "at most the shader's 32");
}
/// A frame with a fixed picture, and a key that names everything it shows.
fn cached_frame() -> super::Frame {
use std::sync::{Arc, Mutex};
@@ -4195,6 +4226,7 @@ mod tests {
outline: false,
eye: [0.0; 4],
ao_radius: 0.0,
ao_samples: crate::view::AO_SAMPLES,
ssaa: 1.0,
}
}
@@ -4238,6 +4270,8 @@ mod tests {
("selection tint", key(|f| f.selection_tint = [0.4, 0.5, 0.6])),
("outline", key(|f| f.outline = true)),
("ambient occlusion", key(|f| f.ao_radius = 1.0)),
// The settled view's full count replaces the moving view's picture (#7165).
("ambient occlusion samples", key(|f| f.ao_samples = super::AO_SAMPLES_MOVING)),
("supersampling", key(|f| f.ssaa = 2.0)),
("image", key(|f| f.images.push(image(1)))),
("image pixels", key(|f| f.images.push(image(2)))),
@@ -4517,6 +4551,7 @@ mod glass_tests {
outline: false,
eye: [0.0, 0.0, 100.0, 0.0],
ao_radius: 0.0,
ao_samples: crate::view::AO_SAMPLES,
ssaa: 1.0,
hover_tint: [0.0; 3],
selection_tint: [0.0; 3],
@@ -4690,6 +4725,7 @@ mod glass_tests {
outline: false,
eye: [0.0, 0.0, 100.0, 0.0],
ao_radius: 0.0,
ao_samples: crate::view::AO_SAMPLES,
ssaa,
}
}
+1
View File
@@ -117,6 +117,7 @@ impl Renderer {
outline: false,
eye: [0.0, 0.0, 100.0, 0.0],
ao_radius: 0.0,
ao_samples: crate::view::AO_SAMPLES,
ssaa: 1.0,
hover_tint: [0.0; 3],
selection_tint: [0.0; 3],
+37 -6
View File
@@ -279,7 +279,16 @@ pub(crate) fn render_offscreen(
back,
eye,
size,
Offscreen { tess, product: false, srgb: false, analysis, analysis_colors: colors, ssaa: 1.0, ao_radius: 0.0 },
Offscreen {
tess,
product: false,
srgb: false,
analysis,
analysis_colors: colors,
ssaa: 1.0,
ao_radius: 0.0,
ao_samples: solidcraft_gpu::view::AO_SAMPLES,
},
)
}
@@ -300,7 +309,16 @@ pub(crate) fn render_product_offscreen(
back,
eye,
size,
Offscreen { tess: None, product: true, srgb, analysis: [0.0; 8], analysis_colors: [0.0; 36], ssaa: 1.0, ao_radius: 0.0 },
Offscreen {
tess: None,
product: true,
srgb,
analysis: [0.0; 8],
analysis_colors: [0.0; 36],
ssaa: 1.0,
ao_radius: 0.0,
ao_samples: solidcraft_gpu::view::AO_SAMPLES,
},
)
}
@@ -313,6 +331,7 @@ struct Offscreen<'a> {
analysis_colors: [f32; 36],
ssaa: f32,
ao_radius: f32,
ao_samples: u32,
}
/// [`render_offscreen`] of a scene supersampled `ssaa` times (1: off).
@@ -332,11 +351,21 @@ pub(crate) fn render_offscreen_ssaa(
back,
eye,
size,
Offscreen { tess: None, product: false, srgb: false, analysis: [0.0; 8], analysis_colors: [0.0; 36], ssaa, ao_radius: 0.0 },
Offscreen {
tess: None,
product: false,
srgb: false,
analysis: [0.0; 8],
analysis_colors: [0.0; 36],
ssaa,
ao_radius: 0.0,
ao_samples: solidcraft_gpu::view::AO_SAMPLES,
},
)
}
/// [`render_offscreen`] of a scene with ambient occlusion of `ao_radius` (world units; 0: off).
/// [`render_offscreen`] of a scene with ambient occlusion of `ao_radius` (world units; 0: off),
/// `ao_samples` samples per pixel.
#[cfg(all(test, not(target_arch = "wasm32")))]
pub(crate) fn render_offscreen_ao(
scene: GpuScene,
@@ -345,6 +374,7 @@ pub(crate) fn render_offscreen_ao(
eye: [f32; 4],
size: u32,
ao_radius: f32,
ao_samples: u32,
) -> Option<Vec<u8>> {
offscreen(
scene,
@@ -353,7 +383,7 @@ pub(crate) fn render_offscreen_ao(
back,
eye,
size,
Offscreen { tess: None, product: false, srgb: false, analysis: [0.0; 8], analysis_colors: [0.0; 36], ssaa: 1.0, ao_radius },
Offscreen { tess: None, product: false, srgb: false, analysis: [0.0; 8], analysis_colors: [0.0; 36], ssaa: 1.0, ao_radius, ao_samples },
)
}
@@ -367,7 +397,7 @@ fn offscreen(
size: u32,
options: Offscreen<'_>,
) -> Option<Vec<u8>> {
let Offscreen { tess, product, srgb, analysis, analysis_colors, ssaa, ao_radius } = options;
let Offscreen { tess, product, srgb, analysis, analysis_colors, ssaa, ao_radius, ao_samples } = 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 };
@@ -400,6 +430,7 @@ fn offscreen(
outline: false,
eye,
ao_radius,
ao_samples,
ssaa,
hover_tint: [0.0; 3],
selection_tint: [0.0; 3],
+4 -1
View File
@@ -2575,9 +2575,12 @@ impl SolveApp {
fn issue_screenshots(&mut self, ctx: &egui::Context) {
let now = now_ms();
// A view that just moved is drawn with fewer AO samples: shoot the full-quality frame
// that follows (#7165), or after half a second a view that keeps moving as it is.
let settled = viewport::ao_settled(self, ctx);
self.queued_shots.retain_mut(|(token, at, frames)| {
*frames += 1;
if now >= *at && *frames >= 3 {
if now >= *at && *frames >= 3 && (settled || now >= *at + 500.0) {
ctx.send_viewport_cmd(egui::ViewportCommand::Screenshot(egui::UserData::new(*token)));
false
} else {
+1
View File
@@ -1808,6 +1808,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {
outline: false,
// Product rendering has its own lighting; AO is a Design viewport setting.
ao_radius: 0.0,
ao_samples: solidcraft_gpu::view::AO_SAMPLES,
eye: [eye.x as f32, eye.y as f32, eye.z as f32, if camera.fov > 0.0 { 1.0 } else { 0.0 }],
ssaa: if width < full.0 { width as f32 / full.0 as f32 } else { 1.0 },
hover_tint: [f32::from(Tokens::get().hover_face_lift) / 255.0; 3],
+1
View File
@@ -287,6 +287,7 @@ pub(crate) fn view_frame(
outline: false,
eye: [e[0], e[1], e[2], if proj.cam.fov > 0.0 { 1.0 } else { 0.0 }],
ao_radius: 0.0,
ao_samples: solidcraft_gpu::view::AO_SAMPLES,
ssaa: 1.0,
hover_tint: [f32::from(t.hover_face_lift) / 255.0; 3],
selection_tint: [0.4, 0.6, 0.9],
+106 -29
View File
@@ -189,8 +189,8 @@ pub struct ViewportState {
/// Unsnapped camera while Shift-orbit previews a standard or diagonal view.
pub orbit_free: Option<Camera>,
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).
/// Adaptive supersampling (#1288) and ambient occlusion while moving (#7165): 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>,
@@ -539,6 +539,30 @@ fn supersampling(app: &mut SolveApp, ctx: &egui::Context, view_proj: [[f32; 4];
if !app.preferences.supersampling_adaptive {
return factor;
}
if view_settled(app, ctx, view_proj, size_px) { factor } else { 1.0 }
}
/// Ambient occlusion samples per pixel this frame (#7165): the full count once the view has held
/// still for a moment, fewer while it moves, so orbiting with AO on stays quick.
fn ao_samples(app: &mut SolveApp, ctx: &egui::Context, view_proj: [[f32; 4]; 4], size_px: [f32; 2]) -> u32 {
// Without AO (off, or wireframe) the count is unused: no repaint is asked for it.
if !app.preferences.ambient_occlusion || app.ui.visual_style == 2 || view_settled(app, ctx, view_proj, size_px) {
solidcraft_gpu::view::AO_SAMPLES
} else {
solidcraft_gpu::view::AO_SAMPLES_MOVING
}
}
/// Whether the frame on screen is the full-quality one a screenshot should wait for: with
/// ambient occlusion drawn, the view has held still for [`SS_SETTLE`], so the picture has all
/// its samples (#7165). Reads the state the last painted frame left.
pub(crate) fn ao_settled(app: &SolveApp, ctx: &egui::Context) -> bool {
!app.preferences.ambient_occlusion || app.ui.visual_style == 2 || ctx.input(|i| i.time) - app.viewport.ss_view.1 >= SS_SETTLE
}
/// Whether the view (its view-projection and pixels) has held still for [`SS_SETTLE`]. Until it
/// has, a repaint is asked for when it will have, so the full-quality frame follows by itself.
fn view_settled(app: &mut SolveApp, ctx: &egui::Context, view_proj: [[f32; 4]; 4], size_px: [f32; 2]) -> bool {
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();
@@ -547,16 +571,14 @@ fn supersampling(app: &mut SolveApp, ctx: &egui::Context, view_proj: [[f32; 4];
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.
if still < SS_SETTLE {
ctx.request_repaint_after(std::time::Duration::from_secs_f64(SS_SETTLE - still + 0.01));
1.0
}
still >= SS_SETTLE
}
/// How long the view holds still before adaptive supersampling draws it at full quality (s).
/// How long the view holds still before adaptive supersampling and ambient occlusion draw it at
/// full quality (s).
const SS_SETTLE: f64 = 0.25;
/// How far (screen points) a press must be dragged for its release to draw a rectangle, circle
@@ -3938,8 +3960,10 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {
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 ao_samples = ao_samples(app, ui.ctx(), proj.vp.to_f32(), size_px);
let cb = ViewportCallback(Frame {
ssaa,
ao_samples,
product: false,
key: app.viewport.key,
slot: app.viewport.slot.clone(),
@@ -5960,6 +5984,43 @@ mod tests {
assert!(drawn > n / 20, "the model is drawn: {drawn} pixels");
}
/// Ambient occlusion while the view moves (#7165): fewer samples for a moving view, the full
/// count once it has held still for `SS_SETTLE`, and the full count whenever AO is off.
#[test]
fn ambient_occlusion_takes_fewer_samples_while_the_view_moves() {
use solidcraft_gpu::view::{AO_SAMPLES, AO_SAMPLES_MOVING};
let mut app = SolveApp::new(solidcraft_engine::Session::default(), crate::Services::default());
let ctx = egui::Context::default();
let size = [800.0, 600.0];
let view = |x: f32| {
let mut m = [[0.0; 4]; 4];
(0..4).for_each(|i| m[i][i] = 1.0);
m[3][0] = x;
m
};
// The samples drawn, and whether the frame asks to be drawn again by the time the view
// will have settled (with no input to wake the window, the full count must follow).
let at = |app: &mut SolveApp, time: f64, x: f32| {
let mut n = 0;
let out = ctx.run_ui(egui::RawInput { time: Some(time), ..Default::default() }, |ui| n = ao_samples(app, ui.ctx(), view(x), size));
let delay = out.viewport_output.get(&egui::ViewportId::ROOT).map_or(std::time::Duration::MAX, |v| v.repaint_delay);
(n, delay <= std::time::Duration::from_secs_f64(SS_SETTLE + 0.02))
};
// A new context asks for its own first repaints: let it settle.
for _ in 0..3 {
let _ = ctx.run_ui(egui::RawInput { time: Some(0.0), ..Default::default() }, |_| {});
}
app.preferences.ambient_occlusion = false;
assert_eq!(at(&mut app, 0.0, 0.0), (AO_SAMPLES, false), "AO off");
app.preferences.ambient_occlusion = true;
assert_eq!(at(&mut app, 1.0, 1.0), (AO_SAMPLES_MOVING, true), "the view just moved");
assert_eq!(at(&mut app, 1.1, 1.0), (AO_SAMPLES_MOVING, true), "still for less than the settling time");
assert_eq!(at(&mut app, 1.0 + SS_SETTLE + 0.01, 1.0), (AO_SAMPLES, false), "settled");
assert_eq!(at(&mut app, 1.4, 2.0), (AO_SAMPLES_MOVING, true), "moved again");
app.ui.visual_style = 2;
assert_eq!(at(&mut app, 1.45, 3.0), (AO_SAMPLES, false), "wireframe draws no AO");
}
/// 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
@@ -6023,6 +6084,7 @@ mod tests {
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn ambient_occlusion_draws_no_copies_of_a_part() {
use solidcraft_gpu::view::{AO_SAMPLES, AO_SAMPLES_MOVING};
let mut s = solidcraft_engine::Session::default();
s.execute("solid.box", &json!({"length": 300, "width": 300, "height": 4, "corner": [-150, -150, -4], "body_name": "plate"})).unwrap();
s.execute("solid.box", &json!({"length": 30, "width": 160, "height": 16, "corner": [0, -80, 0], "operation": "new", "body_name": "block"}))
@@ -6041,9 +6103,10 @@ mod tests {
let proj = projection(&app, rect);
let e = proj.cam.eye().to_f32();
let eye = [e[0], e[1], e[2], 0.0];
let render =
|radius: f32| crate::gpu::render_offscreen_ao(build_scene(&app).merged(), proj.vp.to_f32(), proj.cam.back().to_f32(), eye, SIZE, radius);
let (Some(off), Some(on)) = (render(0.0), render(RADIUS)) else {
let render = |radius: f32, samples: u32| {
crate::gpu::render_offscreen_ao(build_scene(&app).merged(), proj.vp.to_f32(), proj.cam.back().to_f32(), eye, SIZE, radius, samples)
};
let Some(off) = render(0.0, AO_SAMPLES) else {
eprintln!("skipping: no GPU adapter");
return;
};
@@ -6057,24 +6120,37 @@ mod tests {
let (y0, y1) = (a.min(b), a.max(b));
assert!(reach > 100.0 && y1 > y0 + 20, "{reach} px, rows {y0}..{y1}");
let lum = |img: &[u8], x: usize, y: usize| img[(y * SIZE as usize + x) * 4..][..3].iter().map(|&c| f64::from(c)).sum::<f64>();
// The plate's visibility in each column: its brightness with AO over its brightness
// without, averaged over the rows.
let column = |x: usize| (y0..y1).map(|y| lum(&on, x, y) / lum(&off, x, y).max(1.0)).sum::<f64>() / (y1 - y0) as f64;
// From 30 px beyond the radius up to 4 px from the block (its outline).
let from = (edge - reach - 30.0) as usize;
let profile: Vec<f64> = (from..=(edge - 4.0) as usize).map(column).collect();
let (clear, shaded) = (&profile[..20], &profile[30..]);
let step = shaded.windows(2).map(|p| (p[1] - p[0]).abs()).fold(0.0, f64::max);
eprintln!(
"plate {} without AO; edge {edge:.1} px, radius {reach:.1} px, rows {y0}..{y1}; clear {:.4}..{:.4}; next to the block {:.4}; largest step {step:.4}",
lum(&off, from, y0) / 3.0,
clear.iter().copied().fold(f64::INFINITY, f64::min),
clear.iter().copied().fold(0.0, f64::max),
profile[profile.len() - 1],
);
assert!(profile[profile.len() - 1] < 0.98, "the plate darkens beside the block: {:.4}", profile[profile.len() - 1]);
assert!(clear.iter().all(|v| (v - 1.0).abs() < 0.004), "the plate is clear beyond the radius: {clear:?}");
assert!(step < 0.005, "no copies of the block's outline: a step of {step:.4} between neighbouring columns");
// The still picture's samples, and the fewer drawn while the view moves (#7165).
let mut beside = Vec::new();
let mut pictures = Vec::new();
for samples in [AO_SAMPLES, AO_SAMPLES_MOVING] {
let Some(on) = render(RADIUS, samples) else { return };
let on = &on;
// The plate's visibility in each column: its brightness with AO over its brightness
// without, averaged over the rows.
let column = |x: usize| (y0..y1).map(|y| lum(on, x, y) / lum(&off, x, y).max(1.0)).sum::<f64>() / (y1 - y0) as f64;
// From 30 px beyond the radius up to 4 px from the block (its outline).
let from = (edge - reach - 30.0) as usize;
let profile: Vec<f64> = (from..=(edge - 4.0) as usize).map(column).collect();
let (clear, shaded) = (&profile[..20], &profile[30..]);
let step = shaded.windows(2).map(|p| (p[1] - p[0]).abs()).fold(0.0, f64::max);
eprintln!(
"{samples} samples: plate {} without AO; edge {edge:.1} px, radius {reach:.1} px, rows {y0}..{y1}; clear {:.4}..{:.4}; next to the block {:.4}; largest step {step:.4}",
lum(&off, from, y0) / 3.0,
clear.iter().copied().fold(f64::INFINITY, f64::min),
clear.iter().copied().fold(0.0, f64::max),
profile[profile.len() - 1],
);
assert!(profile[profile.len() - 1] < 0.98, "{samples} samples: the plate darkens beside the block: {:.4}", profile[profile.len() - 1]);
assert!(clear.iter().all(|v| (v - 1.0).abs() < 0.004), "{samples} samples: the plate is clear beyond the radius: {clear:?}");
assert!(step < 0.005, "{samples} samples: no copies of the block's outline: a step of {step:.4} between neighbouring columns");
beside.push(profile[profile.len() - 1]);
pictures.push(on.clone());
}
// The shader takes the count it is given (the moving frame is a different picture), and
// spreads it over the same hemisphere: both darken the contact alike.
assert_ne!(pictures[0], pictures[1], "8 samples draw another grain than 32");
assert!((beside[0] - beside[1]).abs() < 0.02, "the same darkening beside the block at 32 and 8 samples: {beside:?}");
}
/// Faded and see-through bodies are drawn from their plans where the renderer blends them
@@ -7000,6 +7076,7 @@ mod tests {
outline: true,
eye: [e[0], e[1], e[2], if proj.cam.fov > 0.0 { 1.0 } else { 0.0 }],
ao_radius: 0.0,
ao_samples: solidcraft_gpu::view::AO_SAMPLES,
ssaa: 1.0,
hover_tint: [0.0; 3],
selection_tint: [0.0; 3],
+24 -1
View File
@@ -34,7 +34,11 @@ The GPU viewport uses 32 hemisphere samples per shaded pixel against an opaque d
prepass (at most 2048 pixels on its longest side), the sample pattern turned by a
different angle at each pixel. One pattern for every pixel drew faint shifted copies of
nearby parts (#4167) and stepped bands along contacts (#3407); turned, they become an
even fine grain, which 2× supersampling smooths further. The radius follows
even fine grain, which 2× supersampling smooths further. While the view moves (orbit, pan,
zoom, resize), frames take 8 samples on the same turned pattern, and the full 32 follow once
the view has held still for 0.25 s, the settling time adaptive supersampling uses (#7165).
The AO grain changes when the full count arrives, as the edges do when adaptive supersampling
does. `ui.screenshot` waits for that full-quality frame (at most half a second). The radius follows
model size, and depth-range rejection avoids shadows from distant foreground objects.
It supports orthographic and perspective cameras and respects section clipping.
Wireframe, transparent bodies, overlays and surface-analysis colours are unaffected.
@@ -102,3 +106,22 @@ Per-trial medians (ms), in chronological order:
- sample-quality: 5.82, 4.48, 7.08.
- 25-plates-performance: 3.13, 3.16, 3.14.
- 25-plates-quality: 6.80, 7.02, 6.95.
## AO while the view moves (2026-10-26, #7165)
Apple M4 Max, macOS 27, release build, MSAA 4x, ground shadow on, normal display quality,
supersampling off. The design is `solidcraft-cli bench-agent --save` (1,280 bodies, 767,476
triangles), fitted to a 1600 x 960 point viewport. The camera was turned through `ui.camera`
every 8 ms for 6 seconds while a Metal System Trace recorded the window. The figure is the
median fragment time of the command buffers that drew the scene (over 1 ms of GPU work), one
trace per configuration, three interleaved series.
| | Series 1 | Series 2 | Series 3 |
|---|---:|---:|---:|
| AO off | 3.79 ms | 4.16 ms | 3.82 ms |
| AO on, 32 samples while moving (before) | 4.48 ms | 5.41 ms | 4.70 ms |
| AO on, 8 samples while moving | 3.96 ms | 3.80 ms | 4.17 ms |
AO added about 0.9 ms of fragment time to each moving frame before, and adds about 0.06 ms
now. The still frame and its cost are unchanged. This is one machine and one design; the
ratio, not the milliseconds, is what carries over to slower GPUs.