Skip to content

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

Viewport: blend grid levels while zooming instead of popping (#9570) (#9608)

kaltenbrunnermarkus76e009ab100c
diff --git a/crates/engine/src/view.rs b/crates/engine/src/view.rs
index 85d4e1274e..a9cb64d6d9 100644
--- a/crates/engine/src/view.rs
+++ b/crates/engine/src/view.rs
@@ -223,6 +223,183 @@ pub fn grid_step(half_height: f64) -> (f64, f64) {
(minor, minor * 5.0)
}
+/// How wide the cross-fade between two grid levels is, in powers of ten of the view's height
+/// (#9570): about 19% of zoom either side of the switch. The switches are at least
+/// `log10(2)` apart, so two cross-fades never overlap.
+const GRID_LEVEL_BLEND: f64 = 0.15;
+
+/// One level of the drawn grid: its spacing and how strongly it is drawn.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct GridLevel {
+ pub minor: f64,
+ pub major: f64,
+ /// 0..1, the level's share of the cross-fade; the levels drawn at one zoom add up to 1. The
+ /// lines only this level has may be drawn weaker than its share ([`grid_lines`]).
+ pub weight: f32,
+}
+
+/// Where the view is in a cross-fade between two grid levels (#9570).
+#[derive(Clone, Copy, Debug)]
+struct GridBlend {
+ /// The finer and the coarser level's minor steps.
+ lo: f64,
+ hi: f64,
+ /// 0..1 through the cross-fade; the switch of [`grid_step`] is at 0.5.
+ s: f64,
+ /// Whether the coarser step is a whole multiple of the finer one (1 to 2, 5 to 10), so that
+ /// every coarser line is also a finer one. From 2 to 5 it is not.
+ nested: bool,
+}
+
+impl GridBlend {
+ /// The coarser level's share of the cross-fade: a smoothstep through it.
+ fn share_hi(&self) -> f32 {
+ smoothstep(self.s) as f32
+ }
+
+ /// How strongly the lines only one of the two levels has are drawn (finer, coarser).
+ ///
+ /// Nested levels cross-fade as their shares do. Levels that do not nest (2 and 5: lines at
+ /// 0, 2, 4, 5, 6, 8, 10 mm) look restless drawn together, so the finer level's own lines fade
+ /// out over the first half of the cross-fade and the coarser level's own lines fade in over
+ /// the second: the two are never seen at once. The lines both share (every 10 mm, the finer
+ /// level's major lines) stay at full strength throughout, so the grid never goes blank.
+ fn own(&self) -> (f32, f32) {
+ if self.nested {
+ let hi = self.share_hi();
+ (1.0 - hi, hi)
+ } else {
+ (smoothstep(1.0 - 2.0 * self.s) as f32, smoothstep(2.0 * self.s - 1.0) as f32)
+ }
+ }
+}
+
+fn smoothstep(x: f64) -> f64 {
+ let x = x.clamp(0.0, 1.0);
+ x * x * (3.0 - 2.0 * x)
+}
+
+/// The cross-fade the view of the given half height is in, if any (#9570).
+fn grid_blend(half_height: f64) -> Option<GridBlend> {
+ let (minor, _) = grid_step(half_height);
+ let raw = half_height / 10.0;
+ // grid_step's floor: no finer level is ever drawn, so there is nothing to fade to.
+ if !raw.is_finite() || !minor.is_finite() || raw <= 1e-3 || minor <= 0.0 {
+ return None;
+ }
+ let p = 10f64.powf((minor.log10() + 1e-9).floor());
+ let mantissa = (minor / p).round();
+ // The neighbouring steps of the 1, 2, 5 sequence.
+ let (finer, coarser) = if mantissa < 1.5 {
+ (minor * 0.5, minor * 2.0)
+ } else if mantissa < 3.5 {
+ (minor * 0.5, minor * 2.5)
+ } else {
+ (minor * 0.4, minor * 2.0)
+ };
+ let half = GRID_LEVEL_BLEND * 0.5;
+ let l = raw.log10();
+ // Zooming out, the switch into the coarser level comes at `log10(coarser)`; zooming in,
+ // the switch into this level was at `log10(minor)`, below which the finer level returns.
+ let (lo, hi) = if coarser.log10() - l < half {
+ (minor, coarser)
+ } else if l - minor.log10() < half && finer >= 1e-3 * (1.0 - 1e-9) {
+ (finer, minor)
+ } else {
+ return None;
+ };
+ let s = ((l - hi.log10()) / GRID_LEVEL_BLEND + 0.5).clamp(0.0, 1.0);
+ // The switch from 2 to 5 is the only one whose coarser step is not a whole multiple of the
+ // finer one. It takes the same zoom range as the others, so the grid is cross-fading at the
+ // same zooms as before; its two halves are each as long as half a nested cross-fade.
+ let nested = ((hi / lo) - (hi / lo).round()).abs() < 1e-6;
+ Some(GridBlend { lo, hi, s, nested })
+}
+
+/// The grid levels drawn for a view of the given half height (#9570).
+///
+/// [`grid_step`] switches the spacing in a step (1, 2, 5 times a power of ten), so the whole grid
+/// used to swap at once as the view zoomed through a switch, popping over and over while
+/// scrolling. Near a switch the drawn grid now cross-fades: the outgoing and incoming levels are
+/// both drawn, weighted by how far the zoom is through the switch (from 2 to 5 one after the
+/// other, see [`grid_lines`]). Away from a switch only the level [`grid_step`] gives is drawn, at
+/// full strength, so the grid looks as it did. The level with the larger weight is always
+/// [`grid_step`]'s, which sketch snapping, dash lengths and the tools keep using unchanged: only
+/// the drawing fades.
+pub fn grid_levels(half_height: f64) -> Vec<GridLevel> {
+ let Some(b) = grid_blend(half_height) else {
+ let (minor, major) = grid_step(half_height);
+ return vec![GridLevel { minor, major, weight: 1.0 }];
+ };
+ let w_hi = b.share_hi();
+ [GridLevel { minor: b.lo, major: b.lo * 5.0, weight: 1.0 - w_hi }, GridLevel { minor: b.hi, major: b.hi * 5.0, weight: w_hi }]
+ .into_iter()
+ .filter(|g| g.weight > 0.0)
+ .collect()
+}
+
+/// One line of the drawn grid (#9570), across one of the grid's axes.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct GridLineAt {
+ /// Where the line crosses the axis, measured from the grid's centre.
+ pub offset: f64,
+ /// How strongly it is drawn (0..1), before the fade with the distance ([`GridFade`]).
+ pub weight: f32,
+ /// How much of that weight is a major line (0..1): the line's colour and width blend from
+ /// the minor to the major ones by it.
+ pub major: f32,
+}
+
+/// The lines of the grid across one axis, for a view of the given half height: every level of
+/// [`grid_levels`], at the grid's own places on the plane (multiples of its step from the plane's
+/// origin), so that a level fading in lies where it will stay once it is the only one. `at` is
+/// the grid's centre on that axis, measured from the plane's origin; the lines reach `reach`
+/// either side of it, at most `cap` steps of each level. A line two levels share is drawn once,
+/// with their weights added; a line only one level has is drawn as strongly as that level's own
+/// lines, which from 2 to 5 fade one after the other, never both at once.
+pub fn grid_lines(half_height: f64, at: f64, reach: f64, cap: i64) -> Vec<GridLineAt> {
+ if !at.is_finite() {
+ return Vec::new();
+ }
+ // (minor step, share of the cross-fade, strength of its own lines) per level.
+ let levels: Vec<(f64, f32, f32)> = match grid_blend(half_height) {
+ Some(b) => {
+ let (share_hi, (own_lo, own_hi)) = (b.share_hi(), b.own());
+ vec![(b.lo, 1.0 - share_hi, own_lo), (b.hi, share_hi, own_hi)]
+ }
+ None => vec![(grid_step(half_height).0, 1.0, 1.0)],
+ };
+ // (line, own strength, shared by two levels)
+ let mut out: Vec<(GridLineAt, f32, bool)> = Vec::new();
+ for &(step, share, own) in &levels {
+ let k0 = (at / step).round();
+ if !k0.is_finite() {
+ continue;
+ }
+ let n = ((reach / step) as i64).clamp(1, cap.max(1));
+ for i in -n..=n {
+ let k = (k0 as i64).saturating_add(i);
+ let major = if k.rem_euclid(5) == 0 { 1.0 } else { 0.0 };
+ out.push((GridLineAt { offset: k as f64 * step - at, weight: share, major }, own, false));
+ }
+ }
+ out.sort_by(|a, b| a.0.offset.total_cmp(&b.0.offset));
+ let tol = levels.iter().map(|l| l.0).fold(f64::INFINITY, f64::min) * 1e-6;
+ let mut merged: Vec<(GridLineAt, f32, bool)> = Vec::with_capacity(out.len());
+ for (line, own, _) in out {
+ match merged.last_mut() {
+ Some((last, _, shared)) if (line.offset - last.offset).abs() <= tol => {
+ let weight = last.weight + line.weight;
+ last.major = if weight > 0.0 { (last.major * last.weight + line.major * line.weight) / weight } else { last.major };
+ last.weight = weight.min(1.0);
+ *shared = true;
+ }
+ _ => merged.push((line, own, false)),
+ }
+ }
+ merged.into_iter().map(|(line, own, shared)| if shared { line } else { GridLineAt { weight: own, ..line } }).filter(|l| l.weight > 0.0).collect()
+}
+
/// 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
@@ -603,7 +780,7 @@ fn build_scene(
sc.radius = (b.diagonal() * 0.5).max(cam.half_height()).max(10.0) + b.center().dist(cam.target);
// 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 major = grid_step(cam.half_height()).1;
// 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, slant, w): (Vec3, Vec3, Vec3, f64, Box<dyn Fn(Vec3) -> Vec3>) = if let Some(pl) = open_sketch_plane(s) {
@@ -624,23 +801,31 @@ fn build_scene(
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 };
- // 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 grid's centre on each axis, from the plane's origin (the world's, or the sketch
+ // plane's): a level fading in near a switch of the spacing lies on its own places (#9570).
+ let origin = open_sketch_plane(s).map_or(Vec3::ZERO, |pl| pl.origin);
+ let (at_u, at_v) = ((c - origin).dot(u), (c - origin).dot(v));
+ // Two lines through the point `c + u * t`: one along v, one along u.
+ for (along, across, at) in [(v, u, at_u), (u, v, at_v)] {
+ for line in grid_lines(cam.half_height(), at, fade.end, 400) {
+ let t = line.offset;
+ // The viewport's widths (pixels). The headless picture keeps the palette's two
+ // grid colours: a line two levels share with different kinds is drawn as both,
+ // each as strong as its share.
+ let width = 0.7 + 0.3 * f64::from(line.major);
+ for (col, share) in [(p.grid_major, line.major), (p.grid, 1.0 - line.major)] {
+ if share <= 0.0 {
+ continue;
+ }
+ 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: alpha * line.weight * share,
+ width,
+ on_top: false,
+ });
+ }
}
}
}
diff --git a/crates/engine/src/view_palette_tests.rs b/crates/engine/src/view_palette_tests.rs
index 4b991e3254..9407bab939 100644
--- a/crates/engine/src/view_palette_tests.rs
+++ b/crates/engine/src/view_palette_tests.rs
@@ -75,6 +75,133 @@ fn the_grid_reaches_further_as_its_plane_is_seen_at_a_slant() {
assert!(grid_ext(40.0, major, 0.0).is_finite());
}
+/// #9570: zooming through a switch of the grid's spacing used to swap the whole grid at once, so
+/// scrolling made it pop over and over. The drawn grid now cross-fades: zoomed in small steps
+/// through a switch, no line's strength jumps from one step to the next, while away from a
+/// switch only [`grid_step`]'s level is drawn, at full strength, as before.
+#[test]
+fn the_grid_cross_fades_between_levels_as_the_view_zooms() {
+ // Every 1, 2, 5 switch, zoomed by 1% a step from a half height of 8 to 1200.
+ let strengths = |hh: f64| {
+ let mut m = std::collections::BTreeMap::new();
+ // The grid's centre off the origin, as when the view has panned: each level's lines
+ // stay on the plane's own places.
+ let at = 37.0;
+ for l in grid_lines(hh, at, 60.0 * hh, 4000) {
+ let world = l.offset + at;
+ // Weight and major share, keyed by the line's place on the plane (to 1e-6 mm).
+ m.insert((world * 1e6).round() as i64, (l.weight, l.major));
+ }
+ m
+ };
+ let mut hh = 8.0;
+ let mut prev = strengths(hh);
+ let mut faded = 0;
+ while hh < 1200.0 {
+ let next_hh = hh * 1.01;
+ let next = strengths(next_hh);
+ // Only lines both steps draw: compare within the smaller reach, short of its ends, where
+ // each level stops at a whole number of its steps.
+ let reach = ((60.0 * hh - hh / 4.0) * 1e6) as i64;
+ for key in prev.keys().chain(next.keys()).filter(|k| (**k - 37_000_000).abs() < reach) {
+ let (a, ma) = prev.get(key).copied().unwrap_or((0.0, 0.0));
+ let (b, mb) = next.get(key).copied().unwrap_or((0.0, 0.0));
+ assert!((a - b).abs() < 0.1, "the line at {} mm jumps from {a} to {b} zooming from {hh} to {next_hh}", *key as f64 * 1e-6);
+ if a > 0.05 && b > 0.05 {
+ assert!((ma - mb).abs() < 0.1, "the line at {} mm turns from major {ma} to {mb} zooming from {hh} to {next_hh}", *key as f64 * 1e-6);
+ }
+ }
+ let levels = grid_levels(next_hh);
+ let total: f32 = levels.iter().map(|g| g.weight).sum();
+ assert!((total - 1.0).abs() < 1e-5, "the levels at {next_hh} add up to {total}");
+ // The strongest level is the one snapping and the tools use.
+ let strongest = levels.iter().fold(levels[0], |a, g| if g.weight > a.weight { *g } else { a });
+ assert_eq!((strongest.minor, strongest.major), grid_step(next_hh), "at {next_hh} the drawn grid's main level is grid_step's");
+ faded += usize::from(levels.len() == 2);
+ prev = next;
+ hh = next_hh;
+ }
+ assert!(faded > 0, "some steps cross-fade");
+ // Away from a switch (raw step 3 lies between the 2 and 5 switches), one level at full
+ // strength, as the grid always was.
+ assert_eq!(grid_levels(30.0), vec![GridLevel { minor: 2.0, major: 10.0, weight: 1.0 }]);
+ // grid_step's floor and hostile heights draw one level.
+ for hh in [0.0, 1e-9, -5.0, f64::NAN, f64::INFINITY] {
+ assert_eq!(grid_levels(hh).len(), 1, "{hh}");
+ let _ = grid_lines(hh, f64::NAN, 10.0, 10);
+ let _ = grid_lines(hh, 1e300, 1e300, 10);
+ }
+}
+
+/// #9570: the headless picture's grid cross-fades as the viewport's does: right at a nested
+/// switch of the spacing (5 to 10), both levels are drawn, the finer one's own lines at half
+/// strength, in the palette's grid colours only. Right at the switch from 2 to 5, which do not
+/// nest, neither level's own lines are drawn, only the 10 mm lines both share.
+#[test]
+fn the_headless_grid_draws_both_levels_at_a_switch() {
+ let s = Session::default();
+ let mut cam = home_camera(&s);
+ cam.pitch = std::f64::consts::FRAC_PI_2;
+ cam.target = Vec3::ZERO;
+ let strength = |hh: f64, x: f64| {
+ let mut cam = cam;
+ cam.distance *= hh / cam.half_height();
+ assert!((cam.half_height() - hh).abs() < 1e-6);
+ let scene = scene(&s, &cam);
+ assert!(scene.grid.iter().all(|l| [Palette::DEFAULT.grid, Palette::DEFAULT.grid_major].contains(&l.color)));
+ // The strongest piece of the line in each grid colour, added: a line two levels share
+ // with different kinds is drawn in both.
+ let on = |l: &&SceneLine| (l.points[0].x - x).abs() < 1e-6 && (l.points[1].x - x).abs() < 1e-6;
+ [Palette::DEFAULT.grid, Palette::DEFAULT.grid_major]
+ .iter()
+ .map(|c| scene.grid.iter().filter(on).filter(|l| l.color == *c).map(|l| l.alpha).fold(0.0f32, f32::max))
+ .sum::<f32>()
+ };
+ // A half height where grid_step switches from 5 to 10: the 5 mm line (only the finer level)
+ // is drawn at half strength, the 10 mm line (both) at full.
+ let a = strength(100.0, 5.0);
+ assert!(a > 0.3 && a < 0.7, "the line at 5 mm is drawn at {a}, half strength while the levels cross-fade");
+ assert!(strength(100.0, 10.0) > 0.9);
+ // A half height where grid_step switches from 2 to 5.
+ for x in [2.0, 5.0] {
+ let a = strength(50.0, x);
+ assert!(a < 1e-6, "the line at {x} mm is drawn at {a} while 2 and 5 swap");
+ }
+ assert!(strength(50.0, 10.0) > 0.9);
+}
+
+/// #9570: the levels 2 and 5 do not nest, and drawn together they gave lines at 0, 2, 4, 5, 6,
+/// 8, 10 mm, which looked restless. Zooming through that switch the finer level's own lines are
+/// gone before the coarser level's own lines appear, while the lines both share (every 10 mm)
+/// stay at full strength, so the grid never goes blank. Checked in every decade drawn.
+#[test]
+fn the_grid_never_draws_two_levels_that_do_not_nest_at_once() {
+ for scale in [0.1, 1.0, 10.0, 100.0] {
+ // grid_step switches from 2 to 5 (times `scale`) at a half height of 50 times `scale`.
+ let (mut hh, end) = (30.0 * scale, 80.0 * scale);
+ let (mut saw_fine, mut saw_coarse) = (false, false);
+ while hh < end {
+ let lines = grid_lines(hh, 0.0, 60.0 * scale, 4000);
+ let at = |x: f64| lines.iter().filter(|l| (l.offset - x * scale).abs() < 1e-6 * scale).map(|l| l.weight).sum::<f32>();
+ // 2, 4, 6, 8: only the finer level; 5, 15: only the coarser.
+ let fine = [2.0, 4.0, 6.0, 8.0].iter().map(|x| at(*x)).fold(0.0f32, f32::max);
+ let coarse = [5.0, 15.0].iter().map(|x| at(*x)).fold(0.0f32, f32::max);
+ assert!(fine == 0.0 || coarse == 0.0, "at {hh} the 2 and 5 levels are both drawn ({fine}, {coarse})");
+ saw_fine |= fine > 0.0 && fine < 1.0;
+ saw_coarse |= coarse > 0.0 && coarse < 1.0;
+ for x in [0.0, 10.0, 20.0] {
+ assert!(at(x) > 0.999, "at {hh} the line at {x} mm both levels share is drawn at {}", at(x));
+ }
+ hh *= 1.005;
+ }
+ assert!(saw_fine && saw_coarse, "both levels fade rather than swap (scale {scale})");
+ }
+ // The nested switches still cross-fade both levels together: from 1 to 2 (half height 20).
+ let lines = grid_lines(20.0, 0.0, 20.0, 4000);
+ let at = |x: f64| lines.iter().filter(|l| (l.offset - x).abs() < 1e-6).map(|l| l.weight).sum::<f32>();
+ assert!(at(1.0) > 0.3 && at(1.0) < 0.7 && at(2.0) > 0.999, "{} {}", at(1.0), at(2.0));
+}
+
/// 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/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs
index a18cd5ab53..26b6b8c9e1 100644
--- a/crates/ui-egui/src/viewport.rs
+++ b/crates/ui-egui/src/viewport.rs
@@ -8,7 +8,7 @@ use solidcraft_engine::Sel;
use solidcraft_engine::geom::{Plane, Vec2, Vec3};
use solidcraft_engine::render::{Camera, Mat4, Rgb};
use solidcraft_engine::sketch::CurveKind;
-use solidcraft_engine::view::{GridFade, GridPlane, colors, grid_ext, grid_plane, grid_step, sketch_lines_with_sampler};
+use solidcraft_engine::view::{GridFade, GridPlane, colors, grid_ext, grid_lines, grid_plane, grid_step, sketch_lines_with_sampler};
use std::hash::{Hash, Hasher};
use crate::gpu::{Frame, GpuScene, GpuTarget, SceneSlot, ViewportCallback};
@@ -1694,7 +1694,7 @@ fn build_sketch_scene(app: &SolveApp, proj: &Proj) -> GpuScene {
// An open sketch has its grid whatever the Grid switch says, unless the sketch's own Sketch
// Grid option (Sketch panel) is off (#9147); outside a sketch that option is never off.
if (sketch_plane.is_some() || app.ui.show_grid) && !active_view(app).hide_grid {
- let (minor, major) = grid_step(app.cam.half_height());
+ let major = grid_step(app.cam.half_height()).1;
// An open sketch has its grid on its own plane, and so does the plane Create Sketch
// would take; 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
@@ -1743,17 +1743,22 @@ fn build_sketch_scene(app: &SolveApp, proj: &Proj) -> GpuScene {
// 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);
let (grid, grid_major) = (c4(tk.grid), c4(tk.grid_major));
- for i in -n..=n {
- let t = i as f64 * minor;
- let maj = (t / major).round() * major == t;
- let col = if maj { grid_major } else { grid };
- let wd = if maj { 1.0 } else { 0.7 };
- // Two lines through the point `c + u * t`: one along v, one along u.
- for (along, across) in [(v, u), (u, v)] {
+ // Near a switch of the spacing the outgoing and incoming levels cross-fade (#9570), each
+ // line on its own place on the plane: the grid's centre on each axis, from the plane's
+ // origin (the sketch plane's, or the camera frame's).
+ let origin = sketch_plane.as_ref().map_or(Vec3::ZERO, |pl| pl.origin);
+ let (at_u, at_v) = ((c - origin).dot(u), (c - origin).dot(v));
+ // Two lines through the point `c + u * t`: one along v, one along u.
+ for (along, across, at) in [(v, u, at_u), (u, v, at_v)] {
+ for line in grid_lines(app.cam.half_height(), at, fade.end, 300) {
+ let t = line.offset;
+ // A line two levels share with different kinds blends between the minor and
+ // the major look.
+ let col = grid_blend(grid, grid_major, line.major);
+ let wd = 0.7 + 0.3 * line.major;
for (s0, s1, alpha) in fade.pieces(t) {
- let col = sc.color(grid_colour(col, alpha));
+ let col = sc.color(grid_colour(col, alpha * line.weight));
sc.under_line(w3(c + across * t + along * s0), w3(c + across * t + along * s1), col, wd);
}
}
@@ -6129,6 +6134,13 @@ fn points_2d(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {
}
/// A grid line's colour, as faint as the fade makes it.
+/// The grid's minor colour blended towards its major one by `major` (0..1): a line two grid
+/// levels share while they cross-fade, minor in one and major in the other (#9570).
+fn grid_blend(minor: [u8; 4], major: [u8; 4], share: f32) -> [u8; 4] {
+ let t = if share.is_finite() { f64::from(share.clamp(0.0, 1.0)) } else { 0.0 };
+ std::array::from_fn(|i| (f64::from(minor[i]) + (f64::from(major[i]) - f64::from(minor[i])) * t).round().clamp(0.0, 255.0) as u8)
+}
+
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]
}
@@ -11959,6 +11971,53 @@ mod grid_plane_tests {
assert!(farthest < cut, "the grid fades out at {farthest}, short of the cut at {cut}");
}
+ /// #9570: zooming through a switch of the grid's spacing swapped the whole grid at once. At
+ /// a nested switch the window now draws both levels at half strength, each on its own
+ /// places; at the switch from 2 to 5, which do not nest, neither level's own lines; and a
+ /// line two levels share with different kinds takes a colour between the two.
+ #[test]
+ fn the_grid_draws_both_levels_at_a_switch_of_its_spacing() {
+ let rect = Rect::from_min_size(Pos2::ZERO, egui::vec2(800.0, 600.0));
+ // The strongest alpha a line across X at `x` is drawn with, at a half height of `hh`.
+ let alpha_at = |hh: f64, x: f32| {
+ let mut app = SolveApp::new(solidcraft_engine::Session::default(), crate::Services::default());
+ app.ui.show_grid = true;
+ app.ui.perspective = false;
+ app.cam.pitch = std::f64::consts::FRAC_PI_2;
+ app.cam.yaw = 0.0;
+ app.cam.target = Vec3::ZERO;
+ app.cam.distance = 1.0;
+ app.cam.distance = hh / app.cam.half_height();
+ let scene = build_sketch_scene(&app, &projection(&app, rect));
+ scene
+ .under
+ .as_chunks::<32>()
+ .0
+ .iter()
+ .filter(|l| {
+ let f = |at: usize| f32::from_le_bytes(l[at..at + 4].try_into().unwrap());
+ (f(0) - x).abs() < 1e-4 && (f(12) - x).abs() < 1e-4
+ })
+ .filter_map(|l| scene.palette.get(crate::gpu::PaletteIndex(u32::from_le_bytes(l[24..28].try_into().unwrap()))).map(|c| c[3]))
+ .max()
+ .unwrap_or(0)
+ };
+ let full = u16::from(c4(Tokens::get().grid)[3]);
+ // A half height where the spacing switches from 5 to 10 mm (nested): the 5 mm lines
+ // cross-fade at about half strength.
+ let a = u16::from(alpha_at(100.0, 5.0));
+ assert!(a > full / 4 && a < full * 3 / 4, "the line at 5 mm is drawn at {a} of {full}: both levels cross-fade");
+ // From 2 to 5 mm (not nested) the finer level's own lines are gone before the coarser
+ // level's own lines appear: right at the switch neither is drawn, the shared 10 mm are.
+ for x in [2.0, 5.0] {
+ assert_eq!(alpha_at(50.0, x), 0, "the line at {x} mm is drawn while 2 and 5 swap");
+ }
+ assert!(alpha_at(50.0, 10.0) > 0);
+ assert_eq!(grid_blend([0, 0, 0, 0], [200, 100, 50, 255], 0.5), [100, 50, 25, 128]);
+ assert_eq!(grid_blend([1, 2, 3, 4], [9, 9, 9, 9], 0.0), [1, 2, 3, 4]);
+ assert_eq!(grid_blend([1, 2, 3, 4], [9, 9, 9, 9], f32::NAN), [1, 2, 3, 4]);
+ }
+
/// #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