SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Viewport: the grid fades with the distance instead of cutting off (#4214) (#4629)
Homero Thompson4ced1d7bcfbb
diff --git a/crates/engine/src/view.rs b/crates/engine/src/view.rsindex 529e2e48fe..58eba1f15a 100644--- a/crates/engine/src/view.rs+++ b/crates/engine/src/view.rs@@ -209,6 +209,116 @@ pub fn grid_step(half_height: f64) -> (f64, f64) {(minor, minor * 5.0)}+/// How the grid fades out with the distance from the middle of the view (#4214).+///+/// The grid used to stop at a fixed distance, so its edge showed as a cut across the picture. It+/// now fades: at full strength near the middle of the view, and gone before the grid's own edge+/// and before the picture's far plane cuts the ground, so that neither of them shows.+#[derive(Clone, Copy, Debug, PartialEq)]+pub struct GridFade {+ /// The distance from the middle of the view where the grid starts to dim.+ pub start: f64,+ /// The distance from the middle of the view where the grid is gone.+ pub end: f64,+}++impl GridFade {+ /// The fade for a view of the given half height, seen at the given slant (the cosine of the+ /// angle between the view and the grid's plane), over a grid of the given half size, that+ /// reaches no further than `far_reach` before the picture's far plane cuts the ground.+ pub fn new(half_height: f64, slant: f64, ext: f64, far_reach: f64) -> Self {+ // The distance from the middle of the view to its edge, measured on the grid's plane: the+ // ground stretches as it is seen at a slant, as the grid's own size does (#3087).+ let reach = half_height / slant.abs().max(0.25);+ // The grid is gone before its own edge, and before the far plane cuts the ground, so that+ // neither of them shows as a cut.+ let end = (2.2 * reach).min(ext).min(far_reach);+ GridFade { start: 0.6 * reach.min(end), end }+ }++ /// How much of the grid is left at a distance from the middle of the view.+ pub fn alpha(&self, d: f64) -> f32 {+ if !d.is_finite() {+ return 0.0;+ }+ if d <= self.start {+ return 1.0;+ }+ if d >= self.end || self.end <= self.start {+ return 0.0;+ }+ ((self.end - d) / (self.end - self.start)) as f32+ }++ /// The pieces the grid's line at the given offset from the middle is drawn in: each with the+ /// alpha the fade gives it at the distance where it lies. The line runs along the grid's other+ /// axis; it is drawn whole where the grid is at full strength, and in pieces that fade+ /// towards its ends.+ pub fn pieces(&self, offset: f64) -> Vec<(f64, f64, f32)> {+ let mut out = Vec::new();+ let off = offset.abs();+ if !(self.end > 0.0) || off >= self.end {+ return out;+ }+ // Where the grid is still at full strength.+ let solid = if off < self.start { (self.start * self.start - off * off).max(0.0).sqrt() } else { 0.0 };+ if solid > 0.0 {+ out.push((-solid, solid, 1.0));+ }+ // The fading ends, in pieces whose distance from the middle grows evenly, so that the+ // grid dims evenly too.+ let from = off.max(self.start);+ for k in 0..GRID_FADE_STEPS {+ let (d0, d1) =+ (from + (self.end - from) * k as f64 / GRID_FADE_STEPS as f64, from + (self.end - from) * (k + 1) as f64 / GRID_FADE_STEPS as f64);+ let (s0, s1) = ((d0 * d0 - off * off).max(0.0).sqrt(), (d1 * d1 - off * off).max(0.0).sqrt());+ let alpha = self.alpha((d0 + d1) * 0.5);+ if alpha > 0.0 {+ out.push((s0, s1, alpha));+ out.push((-s1, -s0, alpha));+ }+ }+ out+ }+}++/// How many pieces a grid line's fading end is drawn in: enough that the grid dims evenly, few+/// enough that the grid stays cheap to draw.+const GRID_FADE_STEPS: u32 = 12;++/// How far the grid reaches before the picture's far plane cuts the ground: the distance on the+/// grid's plane from the middle of the view to where the far plane ends it (#4214). Looking+/// straight down, the ground's depth does not grow and the far plane never cuts it.+///+/// `c` is the middle of the view and `n` the grid's normal, both in the world.+pub fn grid_far_reach(cam: &Camera, far: f64, c: Vec3, n: Vec3) -> f64 {+ let eye = cam.eye();+ // The direction the camera looks, and where it looks on the grid's plane: the ground's+ // forward direction, which the depth grows along.+ let view = -cam.back();+ let forward = view - n * view.dot(n);+ let len = forward.len();+ if len < 1e-9 {+ return f64::INFINITY;+ }+ let depth = (c - eye).dot(view);+ if far <= depth {+ return 0.0;+ }+ (far - depth) / len+}++/// The grid's half size for a view of the given half height, seen at the given slant (the cosine+/// of the angle between the view and the grid's plane): the grid reaches as far on its plane as+/// the view is wide, which stretches as the plane is seen at a slant (#3087).+///+/// The picture and the window share it, so that they draw the same grid (#4214).+pub fn grid_ext(half_height: f64, major: f64, slant: f64) -> f64 {+ let major = major.max(1e-3);+ let ext = (half_height * 3.0 / major).ceil() * major;+ (ext / slant.abs().max(0.25) / major).ceil() * major+}+/// Sketch curves as world polylines with their colour.pub fn sketch_lines(sk: &Sketch, plane: &Plane, active: bool, determined: &[bool]) -> Vec<(Vec<Vec3>, Rgb, bool)> {sketch_lines_with_sampler(sk, plane, active, determined, world_curve_parts)@@ -480,34 +590,52 @@ fn build_scene(// Grid on the ground plane (XY with Z up, XZ with Y up), drawn under the model as in the viewport.if guides.grid {let (minor, major) = grid_step(cam.half_height());- let ext = (cam.half_height() * 3.0 / major).ceil() * major;// Headless pictures keep the grid on the ground, the viewport's default; an open sketch// has its own plane's grid (world coordinates, no camera frame).- let (c, u, v, w): (Vec3, Vec3, Vec3, Box<dyn Fn(Vec3) -> Vec3>) = if let Some(pl) = open_sketch_plane(s) {+ let (c, u, v, slant, w): (Vec3, Vec3, Vec3, f64, Box<dyn Fn(Vec3) -> Vec3>) = if let Some(pl) = open_sketch_plane(s) {let (c, u, v) = sketch_grid_frame(&pl, cam.target, major);- (c, u, v, Box::new(|p| p))+ let n = u.cross(v);+ (c, u, v, cam.back().dot(n), Box::new(|p| p))} else {let tf = cam.to_frame(cam.target);let (u, v) = (Vec3::X, Vec3::Y);+ let back = cam.to_frame(cam.back());+ let n = u.cross(v);let snap = |a: Vec3| a * ((tf.dot(a) / major).round() * major);- (snap(u) + snap(v), u, v, Box::new(|p| cam.from_frame(p)))+ (snap(u) + snap(v), u, v, back.dot(n), Box::new(|p| cam.from_frame(p)))};- let n = ((ext / minor) as i64).clamp(1, 400);+ // The grid reaches as far on the ground as the view is wide (the ground stretches as it+ // is seen at a slant) and fades out with the distance, so that it dissolves into the+ // distance instead of ending in a cut (#4214).+ let ext = grid_ext(cam.half_height(), major, slant);+ let far_reach = grid_far_reach(cam, cam.clip(sc.radius).1, w(c), w(u.cross(v)));+ let fade = GridFade::new(cam.half_height(), slant, ext, far_reach);+ let n = ((fade.end / minor) as i64).clamp(1, 400);for i in -n..=n {let t = i as f64 * minor;let major_line = (t / major).fract().abs() < 1e-9;let col = if major_line { p.grid_major } else { p.grid };// The viewport's widths (pixels).let width = if major_line { 1.0 } else { 0.7 };- sc.grid.push(SceneLine { points: vec![w(c + u * t - v * ext), w(c + u * t + v * ext)], color: col, width, on_top: false });- sc.grid.push(SceneLine { points: vec![w(c - u * ext + v * t), w(c + u * ext + v * t)], color: col, width, on_top: false });+ // Two lines through the point `c + u * t`: one along v, one along u.+ for (along, across) in [(v, u), (u, v)] {+ for (s0, s1, alpha) in fade.pieces(t) {+ sc.grid.push(SceneLine {+ points: vec![w(c + across * t + along * s0), w(c + across * t + along * s1)],+ color: col,+ alpha,+ width,+ on_top: false,+ });+ }+ }}}// The origin's axes, each unless hidden one by one (`browser.visibility`), as in the viewport.let axis = cam.half_height() * 0.25;for ((name, d), col) in [("X", Vec3::X), ("Y", Vec3::Y), ("Z", Vec3::Z)].into_iter().zip(p.axes) {if guides.axes && !s.visibility.hidden_origin.iter().any(|h| h == name) {- sc.lines.push(SceneLine { points: vec![Vec3::ZERO, d * axis], color: col, width: 1.6, on_top: false });+ sc.lines.push(SceneLine { points: vec![Vec3::ZERO, d * axis], color: col, alpha: 1.0, width: 1.6, on_top: false });}}let selected_occurrences: Vec<String> = s@@ -548,19 +676,19 @@ fn build_scene(&& s.doc.face_colors(body).iter().all(|(_, l)| l.opacity >= 0.999){for (a, b) in crate::cosmetic_threads::segments_with_budget(body, &mesh, &st.threads, &mut thread_budget) {- sc.lines.push(SceneLine { points: vec![a, b], color: p.edge, width: 0.85, on_top: false });+ sc.lines.push(SceneLine { points: vec![a, b], color: p.edge, alpha: 1.0, width: 0.85, on_top: false });}}for (i, e) in mesh.edges.iter().enumerate() {if !mesh.shaded_edge_visible(i) {continue;}- sc.lines.push(SceneLine { points: e.clone(), color: p.edge, width: 1.2, on_top: false });+ sc.lines.push(SceneLine { points: e.clone(), color: p.edge, alpha: 1.0, width: 1.2, on_top: false });}// The outline of the body where the section cuts it.if let Some((o, n)) = section {for (a, b) in section_segments(&mesh, o, n) {- sc.lines.push(SceneLine { points: vec![a, b], color: p.edge, width: 1.6, on_top: false });+ sc.lines.push(SceneLine { points: vec![a, b], color: p.edge, alpha: 1.0, width: 1.6, on_top: false });}}}@@ -570,7 +698,7 @@ fn build_scene(continue;}for (pts, col, cons) in sketch_lines_in(&ss.sketch, &ss.plane, active, &ss.report.curve_determined, &mut sampler, p) {- sc.lines.push(SceneLine { points: pts, color: col, width: if cons { 1.0 } else { 1.6 }, on_top: active });+ sc.lines.push(SceneLine { points: pts, color: col, alpha: 1.0, width: if cons { 1.0 } else { 1.6 }, on_top: active });}}sc@@ -933,7 +1061,13 @@ mod tests {assert!(!section_segments(&s.world_state().bodies[0].mesh(), Vec3::new(0.0, 15.0, 0.0), -Vec3::Y).is_empty());// A marker inside the body, behind the cut face.let red = Rgb(255, 0, 0);- sc.lines.push(SceneLine { points: vec![Vec3::new(5.0, 25.0, 10.0), Vec3::new(35.0, 25.0, 10.0)], color: red, width: 3.0, on_top: false });+ sc.lines.push(SceneLine {+ points: vec![Vec3::new(5.0, 25.0, 10.0), Vec3::new(35.0, 25.0, 10.0)],+ color: red,+ alpha: 1.0,+ width: 3.0,+ on_top: false,+ });let img = solidcraft_render::render(&sc, &cam, 300, 220);let px = || img.rgba.chunks(4);let marker = px().filter(|p| p[0] > 200 && p[1] < 60 && p[2] < 60).count();diff --git a/crates/engine/src/view_palette_tests.rs b/crates/engine/src/view_palette_tests.rsindex db1a027875..4b991e3254 100644--- a/crates/engine/src/view_palette_tests.rs+++ b/crates/engine/src/view_palette_tests.rs@@ -6,6 +6,75 @@ use serde_json::json;use solidcraft_geom::Vec2;use solidcraft_sketch::{LinkGeom, LinkKind, LinkSource};+/// #4214: the grid's fade is at full strength in the middle of the view, and gone before the+/// grid's own edge and before the picture's far plane cuts the ground, so that neither of them+/// shows as a cut.+#[test]+fn the_grid_fades_out_before_its_edge_and_before_the_far_plane() {+ let fade = GridFade::new(40.0, 1.0, 120.0, 90.0);+ assert!(fade.start < fade.end, "the fade has a width");+ assert!(fade.end <= 90.0, "the grid is gone before the far plane cuts the ground at 90");+ assert!(fade.end <= 120.0, "the grid is gone before its own edge at 120");+ assert_eq!(fade.alpha(0.0), 1.0, "the middle of the grid is at full strength");+ assert_eq!(fade.alpha(fade.start), 1.0, "the grid is at full strength up to {}", fade.start);+ assert_eq!(fade.alpha(fade.end), 0.0, "the grid is gone at {}", fade.end);+ assert_eq!(fade.alpha(fade.end * 2.0), 0.0, "the grid does not come back");+ assert_eq!(fade.alpha(f64::NAN), 0.0, "a distance that is not a number fades the grid away");+ // The fade falls evenly.+ let mid = (fade.start + fade.end) * 0.5;+ assert!((fade.alpha(mid) - 0.5).abs() < 0.01, "the fade falls evenly: {} at {mid}", fade.alpha(mid));+}++/// #4214: the headless grid fades out with the distance from the middle of the view, as the+/// viewport's does: the lines near the middle are at full strength, the ones further out are+/// dimmer, and the grid is gone before the distance where it used to stop.+#[test]+fn the_headless_grid_fades_out_with_the_distance() {+ let s = Session::default();+ let mut cam = home_camera(&s);+ // A top view: the ground is the XY plane and the grid is centred on the target.+ cam.pitch = std::f64::consts::FRAC_PI_2;+ cam.target = Vec3::ZERO;+ let scene = scene(&s, &cam);+ assert!(!scene.grid.is_empty(), "the grid is drawn");+ // How far each piece of the grid is from the middle of the view, and the alpha it is drawn+ // with.+ let mut pieces: Vec<(f64, f32)> = scene+ .grid+ .iter()+ .map(|l| {+ let mid = l.points[0] + (l.points[1] - l.points[0]) * 0.5;+ ((mid.x * mid.x + mid.y * mid.y).sqrt(), l.alpha)+ })+ .collect();+ pieces.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));+ // The grid in the middle of the view is at full strength.+ let strongest = pieces.iter().filter(|(d, _)| *d < 1.0).map(|(_, a)| *a).fold(0.0f32, f32::max);+ assert_eq!(strongest, 1.0, "the middle of the grid is at full strength");+ // The further from the middle, the dimmer: the outer half of the grid is fainter than the+ // inner half.+ let (near, far) = pieces.split_at(pieces.len() / 2);+ let mean = |v: &[(f64, f32)]| v.iter().map(|(_, a)| f64::from(*a)).sum::<f64>() / v.len().max(1) as f64;+ assert!(mean(near) > mean(far) + 0.1, "the grid fades: {} near the middle, {} far from it", mean(near), mean(far));+ // The grid is gone before the distance where it used to stop, so its edge never shows.+ let (_, major) = grid_step(cam.half_height());+ let cut = (cam.half_height() * 3.0 / major).ceil() * major;+ let farthest = pieces.last().map(|(d, _)| *d).unwrap_or(0.0);+ assert!(farthest < cut, "the grid fades out at {farthest}, short of the cut at {cut}");+}++/// #4214: the grid's half size, the one the picture and the window share: the grid reaches as far+/// on its plane as the view is wide, and further as the plane is seen at a slant.+#[test]+fn the_grid_reaches_further_as_its_plane_is_seen_at_a_slant() {+ let major = grid_step(40.0).1;+ let flat = grid_ext(40.0, major, 1.0);+ assert_eq!(flat, (40.0 * 3.0 / major).ceil() * major, "seen face on, the grid reaches as far as the view is wide");+ assert!(grid_ext(40.0, major, 0.5) > flat, "seen at a slant, the grid reaches further on its plane");+ // A plane seen edge-on keeps a usable size.+ assert!(grid_ext(40.0, major, 0.0).is_finite());+}+/// No colour here is one of [`colors`] or an appearance below, and each field has its own.const MARK: Palette = Palette {background: (Rgb(1, 2, 3), Rgb(4, 5, 6)),diff --git a/crates/gpu/src/capture.rs b/crates/gpu/src/capture.rsindex 148e1fce47..25c99daa11 100644--- a/crates/gpu/src/capture.rs+++ b/crates/gpu/src/capture.rs@@ -430,15 +430,15 @@ pub fn scene_geometry(scene: &Scene) -> GpuScene {}}}- let c4 = |c: Rgb| [c.0, c.1, c.2, 255];+ let c4 = |c: Rgb, a: f32| [c.0, c.1, c.2, (a.clamp(0.0, 1.0) * 255.0).round() as u8];for l in &scene.grid {for w in l.points.windows(2) {- sc.under_line(w[0].to_f32(), w[1].to_f32(), c4(l.color), l.width as f32);+ sc.under_line(w[0].to_f32(), w[1].to_f32(), c4(l.color, l.alpha), l.width as f32);}}for l in &scene.lines {for w in l.points.windows(2) {- sc.line(w[0].to_f32(), w[1].to_f32(), c4(l.color), l.width as f32, l.on_top);+ sc.line(w[0].to_f32(), w[1].to_f32(), c4(l.color, l.alpha), l.width as f32, l.on_top);}}scdiff --git a/crates/gpu/tests/capture.rs b/crates/gpu/tests/capture.rsindex 2967ed6bef..ff78ad9ab3 100644--- a/crates/gpu/tests/capture.rs+++ b/crates/gpu/tests/capture.rs@@ -7,7 +7,7 @@use serde_json::json;use solidcraft_engine::Session;use solidcraft_engine::geom::Vec3;-use solidcraft_engine::render::{Camera, Rgb, SceneLine};+use solidcraft_engine::render::{Camera, Rgb, Scene, SceneLine};use solidcraft_engine::view::{self, Guides, colors};use solidcraft_gpu::GpuError;use solidcraft_gpu::capture::{self, Capturer};@@ -162,7 +162,13 @@ fn pictures_show_the_section_and_its_cap() {let mut sc = view::scene(&s, &cam);// A marker inside the body, behind the cut face.let red = Rgb(255, 0, 0);- sc.lines.push(SceneLine { points: vec![Vec3::new(5.0, 25.0, 10.0), Vec3::new(35.0, 25.0, 10.0)], color: red, width: 3.0, on_top: false });+ sc.lines.push(SceneLine {+ points: vec![Vec3::new(5.0, 25.0, 10.0), Vec3::new(35.0, 25.0, 10.0)],+ color: red,+ alpha: 1.0,+ width: 3.0,+ on_top: false,+ });let img = c.rgba(&sc, &cam, 300, 220).unwrap();let marker = pixels(&img).filter(|p| p[0] > 200 && p[1] < 60 && p[2] < 60).count();assert_eq!(marker, 0, "fov {fov}: the inside shows through the cut face");@@ -226,6 +232,30 @@ fn a_body_behind_the_cut_does_not_colour_the_cap() {}}+/// #4214: a line that is not opaque is blended with what is under it, so the grid's fade reaches+/// the picture.+#[test]+fn pictures_blend_a_line_that_is_not_opaque() {+ let Some(c) = capturer() else { return };+ let cam = Camera { distance: 50.0, fov: 0.0, ..Default::default() };+ let darkest = |alpha: f32| {+ let mut sc = Scene { radius: 30.0, ..Default::default() };+ sc.lines.push(SceneLine {+ points: vec![Vec3::new(-8.0, 2.0, 0.0), Vec3::new(8.0, 2.0, 0.0)],+ color: Rgb(0, 0, 0),+ alpha,+ width: 1.4,+ on_top: false,+ });+ let img = c.rgba(&sc, &cam, 64, 64).unwrap();+ pixels(&img).map(|p| i32::from(p[0])).min().unwrap_or(255)+ };+ let solid = darkest(1.0);+ let half = darkest(0.5);+ assert!(solid < 40, "the opaque line is black: {solid}");+ assert!(half > 60 && half < 170, "the half-opaque line is between the background and the line: {half} against {solid}");+}+/// Surface analysis shades headless pictures as it shades the viewport: a box's flat faces in/// the curvature map's flat colour, zebra stripes in black and white, the accessibility analysis/// in reachable and blocked colours.diff --git a/crates/gpu/tests/depth.rs b/crates/gpu/tests/depth.rsindex f22848088c..a9be41344e 100644--- a/crates/gpu/tests/depth.rs+++ b/crates/gpu/tests/depth.rs@@ -153,7 +153,7 @@ fn front(mesh: Mesh, lines: Vec<SceneLine>, radius: f64, fov: f64) -> (Scene, Ca}fn red_line(a: Vec3, b: Vec3, on_top: bool) -> SceneLine {- SceneLine { points: vec![a, b], color: Rgb(255, 0, 0), width: 1.2, on_top }+ SceneLine { points: vec![a, b], color: Rgb(255, 0, 0), alpha: 1.0, width: 1.2, on_top }}fn red_pixels(c: &Capturer, scene: &Scene, cam: &Camera) -> usize {@@ -193,7 +193,7 @@ fn a_selected_edge_on_a_grazing_face_draws_whole() {sc.lifted_line(a.to_f32(), b.to_f32(), [255, 0, 0, 255], 6.0, [n.to_f32(), n.to_f32()]);sc};- let reference = |a: Vec3, b: Vec3| vec![SceneLine { points: vec![a, b], color: Rgb(255, 0, 0), width: 6.0, on_top: true }];+ let reference = |a: Vec3, b: Vec3| vec![SceneLine { points: vec![a, b], color: Rgb(255, 0, 0), alpha: 1.0, width: 6.0, on_top: true }];for (mode, c) in capturers() {for tilt in [60.0_f64, 80.0, 85.0, 88.0] {let tr = tilt.to_radians();diff --git a/crates/gpu/tests/thin_lines.rs b/crates/gpu/tests/thin_lines.rsindex c8cff84939..e9b6583f27 100644--- a/crates/gpu/tests/thin_lines.rs+++ b/crates/gpu/tests/thin_lines.rs@@ -35,7 +35,8 @@ fn missing(c: &Capturer, width: f64) -> Vec<usize> {(0..N).filter(|&i| {let z = -4.0 + i as f64 * 0.23;- let line = SceneLine { points: vec![Vec3::new(-8.0, 0.0, z), Vec3::new(8.0, 0.0, z)], color: Rgb(255, 0, 0), width, on_top: true };+ let line =+ SceneLine { points: vec![Vec3::new(-8.0, 0.0, z), Vec3::new(8.0, 0.0, z)], color: Rgb(255, 0, 0), alpha: 1.0, width, on_top: true };let scene = Scene { lines: vec![line], radius: 30.0, ..Default::default() };let img = c.rgba(&scene, &cam, 200, 200).unwrap();!img.as_chunks::<4>().0.iter().any(|p| p[0] > 60 && p[0] > p[1].saturating_add(40) && p[0] > p[2].saturating_add(40))diff --git a/crates/render/src/raster.rs b/crates/render/src/raster.rsindex 68a3f197e2..86ad798a03 100644--- a/crates/render/src/raster.rs+++ b/crates/render/src/raster.rs@@ -230,6 +230,8 @@ pub fn render(scene: &Scene, cam: &Camera, w: usize, h: usize) -> Canvas {}for l in scene.grid.iter().chain(&scene.lines) {let col = l.color.f();+ // A line that is not opaque is blended with what is under it (the grid fading out).+ let alpha = f64::from(l.alpha).clamp(0.0, 1.0);let half = (l.width * SS as f64 * 0.5).max(0.5);for seg in l.points.windows(2) {let (Some(&p), Some(&q)) = (seg.first(), seg.get(1)) else { continue };@@ -264,7 +266,7 @@ pub fn render(scene: &Scene, cam: &Camera, w: usize, h: usize) -> Canvas {let visible = l.on_top|| c.depth.get(i).zip(slope.get(i)).is_some_and(|(dd, s)| z <= f64::from(*dd) + f64::from(*s) * d + z.abs() * DEPTH_EPS);if visible {- c.put(ix as usize, iy as usize, col, cov);+ c.put(ix as usize, iy as usize, col, cov * alpha);}}}@@ -428,6 +430,7 @@ mod tests {lines: vec![SceneLine {points: vec![Vec3::new(-8.0, 2.0, 0.0), Vec3::new(8.0, 2.0, 0.0)],color: Rgb(0, 0, 255),+ alpha: 1.0,width: 1.4,on_top: false,}],@@ -499,6 +502,30 @@ mod tests {render(scene, cam, 64, 64).rgba.chunks(4).filter(|p| p[0] > 150 && p[1] < 100 && p[2] < 100).count()}+ /// #4214: a line that is not opaque is blended with what is under it: the grid fades out+ /// with the distance, and the fade reaches the picture.+ #[test]+ fn a_line_that_is_not_opaque_is_blended_with_what_is_under_it() {+ let line = |alpha: f32| SceneLine {+ points: vec![Vec3::new(-8.0, 2.0, 0.0), Vec3::new(8.0, 2.0, 0.0)],+ color: Rgb(0, 0, 255),+ alpha,+ width: 1.4,+ on_top: false,+ };+ let cam = Camera { distance: 50.0, fov: 0.0, ..Default::default() };+ // The blue of the line over the white background, at full strength and at half.+ let blue = |alpha: f32| {+ let scene = Scene { lines: vec![line(alpha)], radius: 30.0, ..Default::default() };+ let img = render(&scene, &cam, 64, 64);+ img.rgba.chunks(4).map(|p| p[2] as i32).max().unwrap_or(0)+ };+ let solid = blue(1.0);+ let half = blue(0.5);+ assert!(solid > 200, "the opaque line is blue: {solid}");+ assert!(half < solid && half > 100, "the half-opaque line is between the background and the line: {half} against {solid}");+ }+/// An edge 1 mm behind a sheet is hidden in a close view of a large design. The old test/// allowed 2e-4 of the depth range, 2e-4 · (8 · 1200 + 2) = 1.92 mm here (orthographic; far/// more in perspective), so it was drawn on the sheet. Now the allowance is what the sheet's@@ -515,6 +542,7 @@ mod tests {let edge = SceneLine {points: vec![Vec3::new(-10.0, 0.0, 0.0) + back, Vec3::new(10.0, 0.0, 0.0) + back],color: Rgb(255, 0, 0),+ alpha: 1.0,width: 1.2,on_top: false,};@@ -534,7 +562,7 @@ mod tests {fn edges_on_a_steep_face_draw_whole() {let tilt = 70f64.to_radians();let on = |x: f64, z: f64| Vec3::new(x, z * tilt.tan(), z);- let line = |points: Vec<Vec3>| SceneLine { points, color: Rgb(255, 0, 0), width: 1.2, on_top: false };+ let line = |points: Vec<Vec3>| SceneLine { points, color: Rgb(255, 0, 0), alpha: 1.0, width: 1.2, on_top: false };for fov in [0.0, 0.6] {for radius in [30.0, 1200.0] {let lines = vec![diff --git a/crates/render/src/scene.rs b/crates/render/src/scene.rsindex 7b1e62f55d..79744b516d 100644--- a/crates/render/src/scene.rs+++ b/crates/render/src/scene.rs@@ -58,6 +58,9 @@ pub const MIN_ALPHA: f64 = 0.05;pub struct SceneLine {pub points: Vec<Vec3>,pub color: Rgb,+ /// How opaque the line is: 1 is solid, below 1 it is blended with what is under it (the+ /// grid fades out with the distance, #4214).+ pub alpha: f32,/// Width in output pixels.pub width: f64,/// Draw over everything (sketch geometry being edited).diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex 8572525b1c..2ce6067887 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -9,7 +9,7 @@ use solidcraft_engine::Sel;use solidcraft_engine::geom::{Vec2, Vec3};use solidcraft_engine::render::{Camera, Mat4, Rgb};use solidcraft_engine::sketch::CurveKind;-use solidcraft_engine::view::{GridPlane, colors, grid_plane, grid_step, sketch_lines_with_sampler};+use solidcraft_engine::view::{GridFade, GridPlane, colors, grid_ext, grid_plane, grid_step, sketch_lines_with_sampler};use std::hash::{Hash, Hasher};use crate::gpu::{Frame, GpuScene, GpuTarget, SceneSlot, ViewportCallback};@@ -335,6 +335,13 @@ pub fn projection(app: &SolveApp, rect: Rect) -> Proj {Proj { cam, vp: cam.view_proj_bounds(aspect, &scene_bounds(app)), rect }}+/// The far plane the picture's projection uses: the grid's fade ends before that plane cuts the+/// ground (#4214). The scene's radius is not the radius the picture frames, so the planes of the+/// projection itself are the ones that count.+fn picture_far(app: &SolveApp, cam: &Camera) -> f64 {+ cam.clip_bounds(&scene_bounds(app)).1+}+/// Sketches drawn in the viewport: the active one, and finished ones not yet used by a feature.pub(crate) fn visible_sketches(app: &SolveApp) -> Vec<u64> {let st = crate::open_meshing::shown_world(app);@@ -1106,13 +1113,19 @@ fn build_sketch_scene(app: &SolveApp, proj: &Proj) -> GpuScene {let sketch_plane = solidcraft_engine::view::open_sketch_plane(s);if sketch_plane.is_some() || (app.ui.show_grid && !active_view(app).hide_grid) {let (minor, major) = grid_step(app.cam.half_height());- let mut ext = (app.cam.half_height() * 3.0 / major).ceil() * major;// An open sketch always has its grid on its own plane; otherwise the ground plane: XY with// Z up, XZ with Y up (laid out in the camera's Z-up frame), or the upright origin plane// facing the view when the ground is seen edge-on.- let (c, u, v, w3): (Vec3, Vec3, Vec3, Box<dyn Fn(Vec3) -> [f32; 3]>) = if let Some(pl) = &sketch_plane {+ let (c, u, v, slant, ext, far_reach, w3): (Vec3, Vec3, Vec3, f64, f64, f64, Box<dyn Fn(Vec3) -> [f32; 3]>) = if let Some(pl) = &sketch_plane {let (c, u, v) = solidcraft_engine::view::sketch_grid_frame(pl, app.cam.target, major);- (c, u, v, Box::new(|p| p.to_f32()))+ // How steeply the sketch's plane is seen: the grid reaches as far on it as the view+ // is wide, so the fade with the distance does too (#4214). The sketch's plane is in+ // the world, as the camera's direction is.+ let n = u.cross(v);+ let slant = app.cam.back().dot(n);+ let ext = grid_ext(app.cam.half_height(), major, slant);+ let far_reach = solidcraft_engine::view::grid_far_reach(&proj.cam, picture_far(app, &proj.cam), c, n);+ (c, u, v, slant, ext, far_reach, Box::new(|p| p.to_f32()))} else {let tf = app.cam.to_frame(app.cam.target);// On the ground (XY) unless the Grid follows the view preference is on (#1470); then on@@ -1133,19 +1146,32 @@ fn build_sketch_scene(app: &SolveApp, proj: &Proj) -> GpuScene {let back = app.cam.to_frame(app.cam.back());let n = u.cross(v);let slant = back.dot(n);- ext = (ext / slant.abs().max(0.25) / major).ceil() * major;+ let ext = grid_ext(app.cam.half_height(), major, slant);let centre = grid_centre(tf, back, n, ext);let snap = |a: Vec3| a * ((centre.dot(a) / major).round() * major);- (snap(u) + snap(v), u, v, Box::new(|p| app.cam.from_frame(p).to_f32()))+ let c = snap(u) + snap(v);+ // The far plane cuts the ground, and the grid's plane is the camera's frame's.+ let far_reach =+ solidcraft_engine::view::grid_far_reach(&proj.cam, picture_far(app, &proj.cam), app.cam.from_frame(c), app.cam.from_frame(n));+ (c, u, v, slant, ext, far_reach, Box::new(|p| app.cam.from_frame(p).to_f32()))};- let n = ((ext / minor) as i64).clamp(1, 300);+ // The grid fades out with the distance from the middle of the view (#4214): it used to+ // stop at a fixed distance, so its edge showed as a cut across the picture. Each line is+ // now drawn in pieces, each as faint as the fade makes it there, and the grid is gone+ // before its own edge, which is therefore never seen.+ let fade = GridFade::new(app.cam.half_height(), slant, ext, far_reach);+ let n = ((fade.end / minor) as i64).clamp(1, 300);for i in -n..=n {let t = i as f64 * minor;let maj = (t / major).round() * major == t;let col = if maj { c4(tk.grid_major) } else { c4(tk.grid) };let wd = if maj { 1.0 } else { 0.7 };- sc.under_line(w3(c + u * t - v * ext), w3(c + u * t + v * ext), col, wd);- sc.under_line(w3(c - u * ext + v * t), w3(c + u * ext + v * t), col, wd);+ // Two lines through the point `c + u * t`: one along v, one along u.+ for (along, across) in [(v, u), (u, v)] {+ for (s0, s1, alpha) in fade.pieces(t) {+ sc.under_line(w3(c + across * t + along * s0), w3(c + across * t + along * s1), grid_colour(col, alpha), wd);+ }+ }}}for sid in visible_sketches(app) {@@ -4468,6 +4494,11 @@ fn points_2d(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {}}+/// A grid line's colour, as faint as the fade makes it.+fn grid_colour(c: [u8; 4], alpha: f32) -> [u8; 4] {+ [c[0], c[1], c[2], (f64::from(c[3]) * f64::from(alpha)).round().clamp(0.0, 255.0) as u8]+}+/// Where the ground grid is centred: where the view's axis (`back`, through the camera's target/// `tf`) meets the plane through the origin with normal `n`, so the middle of the view has grid/// (#3087). At a grazing slant that point runs far off, and the ground in front of the camera@@ -7523,6 +7554,7 @@ mod tests {scene.lines.push(solidcraft_engine::render::SceneLine {points: edge.clone(),color: solidcraft_engine::view::colors::EDGE,+ alpha: 1.0,width: 1.2,on_top: false,});@@ -9178,6 +9210,177 @@ mod grid_plane_tests {assert!(x > lo[0] && x < hi[0] && y > lo[1] && y < hi[1], "the grid spans {lo:?}..{hi:?}, the middle of the view is at {mid:?}");}+ /// #4214: the grid used to stop at a fixed distance from the view, so its edge showed as a+ /// cut across the picture. It now fades out with the distance from the middle of the view:+ /// the lines near the middle are at full strength, the ones further out are dimmer, and the+ /// grid is gone before the distance where it used to stop.+ #[test]+ fn the_grid_fades_out_with_the_distance_from_the_middle_of_the_view() {+ let rect = Rect::from_min_size(Pos2::ZERO, egui::vec2(800.0, 600.0));+ let mut app = SolveApp::new(solidcraft_engine::Session::default(), crate::Services::default());+ app.ui.show_grid = true;+ app.ui.perspective = false;+ // A top view: the ground is the XY plane, and the grid is centred on the target.+ app.cam.pitch = std::f64::consts::FRAC_PI_2;+ app.cam.yaw = 0.0;+ app.cam.target = Vec3::ZERO;+ app.cam.distance = 100.0;+ let under = build_sketch_scene(&app, &projection(&app, rect)).under;+ // Each line of the grid: two points, a colour and a width.+ let segments: Vec<([f32; 3], [f32; 3], u8)> = under+ .as_chunks::<32>()+ .0+ .iter()+ .map(|l| {+ let point = |at: usize| [0, 4, 8].map(|i| f32::from_le_bytes(l[at + i..at + i + 4].try_into().unwrap()));+ (point(0), point(12), l[27])+ })+ .collect();+ assert!(!segments.is_empty(), "the grid is drawn");+ // How far each piece of the grid is from the middle of the view, and the alpha it is+ // drawn with.+ let mut pieces: Vec<(f64, u8)> = segments+ .iter()+ .map(|(a, b, alpha)| {+ let mid = [0, 1, 2].map(|i| f64::from((a[i] + b[i]) * 0.5));+ ((mid[0] * mid[0] + mid[1] * mid[1]).sqrt(), *alpha)+ })+ .collect();+ pieces.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));+ // The grid in the middle of the view is at full strength.+ assert_eq!(pieces.iter().filter(|(d, _)| *d < 1.0).map(|(_, a)| *a).max(), Some(255), "the middle of the grid is at full strength");+ // The further from the middle, the dimmer: the outer half of the grid is fainter than the+ // inner half.+ let (near, far) = pieces.split_at(pieces.len() / 2);+ let mean = |v: &[(f64, u8)]| v.iter().map(|(_, a)| f64::from(*a)).sum::<f64>() / v.len().max(1) as f64;+ assert!(mean(near) > mean(far) + 10.0, "the grid fades: {} near the middle, {} far from it", mean(near), mean(far));+ // The grid is gone before the distance where it used to stop, so its edge never shows.+ let (_, major) = grid_step(app.cam.half_height());+ let cut = (app.cam.half_height() * 3.0 / major).ceil() * major;+ let farthest = pieces.last().map(|(d, _)| *d).unwrap_or(0.0);+ assert!(farthest < cut, "the grid fades out at {farthest}, short of the cut at {cut}");+ }++ /// #4214: the picture and the window draw the same grid. On a sketch's plane the headless+ /// render's grid used to reach further than the viewport's (the picture stretched the grid+ /// with the slant, the window did not), so a picture saved from the command line and the+ /// window the user sees showed different grids.+ #[test]+ fn the_picture_and_the_window_draw_the_same_grid_on_a_sketch_plane() {+ let rect = Rect::from_min_size(Pos2::ZERO, egui::vec2(800.0, 600.0));+ let mut app = SolveApp::new(solidcraft_engine::Session::default(), crate::Services::default());+ app.run("sketch.create", json!({"plane": "XY"})).unwrap();+ app.ui.perspective = false;+ app.cam.fov = 0.0;+ app.cam.yaw = 0.0;+ app.cam.pitch = 35.0_f64.to_radians();+ app.cam.target = Vec3::ZERO;+ app.cam.distance = 100.0;+ // The grid's centre, as both draw it: the sketch plane's, round the view's target.+ let plane = solidcraft_engine::view::open_sketch_plane(&app.session).unwrap();+ let (_, major) = grid_step(app.cam.half_height());+ let (centre, _, _) = solidcraft_engine::view::sketch_grid_frame(&plane, app.cam.target, major);+ // How far the picture's grid reaches from that centre.+ let scene = solidcraft_engine::view::scene(&app.session, &app.cam);+ let picture = scene.grid.iter().flat_map(|l| l.points.iter()).map(|p| (*p - centre).len()).fold(0.0_f64, f64::max);+ // How far the window's grid reaches: the same points, as bytes.+ let under = build_sketch_scene(&app, &projection(&app, rect)).under;+ let window = under+ .as_chunks::<32>()+ .0+ .iter()+ .flat_map(|l| [&l[0..12], &l[12..24]])+ .map(|b| {+ let p = [0, 4, 8].map(|i| f64::from(f32::from_le_bytes(b[i..i + 4].try_into().unwrap())));+ (Vec3::new(p[0], p[1], p[2]) - centre).len()+ })+ .fold(0.0_f64, f64::max);+ assert!(picture > 0.0, "the picture draws a grid");+ assert!(+ (picture - window).abs() <= 1e-3 * picture.max(window),+ "the picture's grid reaches {picture} mm from the middle of the view, the window's {window} mm"+ );+ }++ /// #4214: the grid fades in the picture as well. The same grid drawn at full strength is+ /// much fainter there where the fade has thinned it, and the same in the middle of the view,+ /// where the fade leaves the grid alone. Where the picture's far plane cuts the ground, the+ /// faded grid is already gone: it fades out instead of ending in a cut.+ #[cfg(not(target_arch = "wasm32"))]+ #[test]+ fn the_grid_fades_out_in_the_picture_instead_of_ending_in_a_cut() {+ const SIZE: u32 = 512;+ let rect = Rect::from_min_size(Pos2::ZERO, egui::vec2(SIZE as f32, SIZE as f32));+ let mut app = SolveApp::new(solidcraft_engine::Session::default(), crate::Services::default());+ app.ui.show_grid = true;+ app.ui.perspective = true;+ // A low view of the ground: the far ground is in the picture, where the grid used to end+ // in a cut.+ app.cam.pitch = 0.25;+ app.cam.yaw = 0.0;+ app.cam.target = Vec3::ZERO;+ app.cam.distance = 100.0;+ let proj = projection(&app, rect);+ let t = Tokens::get();+ 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 = |scene: GpuScene| {+ crate::gpu::render_offscreen(+ scene,+ None,+ proj.vp.to_f32(),+ proj.cam.back().to_f32(),+ eye,+ SIZE,+ None,+ [0.0; 8],+ crate::gpu::analysis_colors(&t.analysis),+ )+ };+ let faded = build_sketch_scene(&app, &proj).merged();+ // The same grid at full strength: every piece of it opaque.+ let mut full = faded.clone();+ for piece in full.under.as_chunks_mut::<32>().0 {+ piece[27] = 255;+ }+ let (Some(faded), Some(full)) = (render(faded), render(full)) else {+ eprintln!("skipping: no GPU adapter");+ return;+ };+ // How far the pixels of each row are from the white the picture was cleared to: the+ // grid's lines show. The ink of a row, from the top of the picture.+ let row_ink = |img: &[u8]| -> Vec<u64> {+ (0..SIZE)+ .map(|y| {+ (0..SIZE)+ .map(|x| {+ let i = ((y * SIZE + x) * 4) as usize;+ img[i..i + 3].iter().map(|c| u64::from(255 - c)).sum::<u64>()+ })+ .sum::<u64>()+ })+ .collect()+ };+ let (faded_rows, full_rows) = (row_ink(&faded), row_ink(&full));+ // The middle of the view: the grid is drawn there, and the fade leaves it alone.+ let middle = SIZE as usize / 2;+ assert!(faded_rows[middle] > 0, "the grid is drawn in the middle of the view");+ assert_eq!(faded_rows[middle], full_rows[middle], "the fade leaves the middle of the grid alone");+ // The first row where the grid at full strength shows: the picture's far plane cuts the+ // ground there, and the rows above it are the far ground the grid has to fade out in.+ let first = full_rows.iter().position(|ink| *ink > 0).expect("the grid is drawn");+ // Where the ground is cut, the faded grid is gone: it fades out instead of ending in a+ // cut (#4214).+ let band = first.saturating_sub(10)..=first;+ let faded_ink: u64 = band.clone().map(|y| faded_rows[y]).sum();+ let full_ink: u64 = band.map(|y| full_rows[y]).sum();+ assert!(full_ink > 0, "the grid shows up to the far plane");+ assert!(+ faded_ink * 4 < full_ink,+ "the grid still shows at full strength where the far plane cuts the ground: {faded_ink} against {full_ink}"+ );+ }+/// An open sketch always has its grid, on its own plane, whatever the Grid switch and the/// follow-the-view preference say; outside a sketch the switch decides.#[test]