From 4cf553645d19387ec607d692c6ee0d9f606587ef Mon Sep 17 00:00:00 2001 From: Taylor Burke Date: Wed, 28 Oct 2026 15:35:09 -0500 Subject: [PATCH 1/2] Color wheel: feather the hue ring and triangle edges (#9996) The ring and the triangle are meshes, which egui doesn't antialias, so their edges were jagged. Both now fade to transparent over egui's feathering width (one physical pixel), centred on each edge, as egui's own shapes do. The triangle's fringe comes from scaling it about its incentre, so corners are mitred and saturation/brightness stay aligned. Hit testing is unchanged. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01E8LSXezwgktJ1driAG4DoA --- crates/ui-egui/src/color_panel_tests.rs | 57 ++++++++++++++++ crates/ui-egui/src/panels/color_panel_ui.rs | 75 +++++++++++++++++---- 2 files changed, 120 insertions(+), 12 deletions(-) diff --git a/crates/ui-egui/src/color_panel_tests.rs b/crates/ui-egui/src/color_panel_tests.rs index a3c1f4b9b0..c6ebe2a7cd 100644 --- a/crates/ui-egui/src/color_panel_tests.rs +++ b/crates/ui-egui/src/color_panel_tests.rs @@ -339,6 +339,63 @@ fn color_wheel_ring_sets_hue_and_triangle_sets_saturation_and_brightness() { assert!((hsv[0] - 90.0).abs() < 4.0 && hsv[1] < 0.9 && hsv[2] < 0.95, "{after:?} {hsv:?}"); } +/// The wheel's ring and triangle are meshes, which egui doesn't antialias: each edge fades to +/// transparent over the feather, centred on it, so neither looks jagged (#9996). +#[test] +fn color_wheel_edges_are_feathered() { + use crate::color_panel_ui::{ring_mesh, triangle_mesh}; + let (center, inner, outer, feather) = (pos2(100.0, 100.0), 80.0, 96.0, 1.0); + let ring = ring_mesh(center, inner, outer, feather); + for v in &ring.vertices { + let r = (v.pos - center).length(); + if v.color == egui::Color32::TRANSPARENT { + let fringe = (r - (inner - 0.5)).abs().min((r - (outer + 0.5)).abs()); + assert!(fringe < 1e-3, "transparent vertex at radius {r}"); + } else { + assert!(r > inner + 0.5 - 1e-3 && r < outer - 0.5 + 1e-3, "solid vertex at radius {r}"); + assert_eq!(v.color.a(), 255); + } + } + assert!(ring.vertices.iter().any(|v| v.color == egui::Color32::TRANSPARENT)); + // Hard edges: no fringe at all. + assert!(ring_mesh(center, inner, outer, 0.0).vertices.iter().all(|v| v.color.a() == 255)); + + // An equilateral triangle in the ring (inradius 39.5): solid vertices half a feather inside + // its edges, transparent ones half a feather outside. + let tri = [0.0f32, 1.0 / 3.0, 2.0 / 3.0].map(|t| { + let a = t * std::f32::consts::TAU; + center + egui::vec2(a.cos(), -a.sin()) * 79.0 + }); + // Signed distance from `p` to the nearest edge, positive inside. + let inside = |p: egui::Pos2| { + (0..3) + .map(|k| { + let (a, b) = (tri[k], tri[(k + 1) % 3]); + let n = egui::vec2(-(b - a).y, (b - a).x).normalized(); + let d = (p - a).dot(n); + if (center - a).dot(n) < 0.0 { -d } else { d } + }) + .fold(f32::INFINITY, f32::min) + }; + let m = triangle_mesh(tri, 0.25, feather); + let (mut solid_edge, mut fringe) = (0, 0); + for v in &m.vertices { + let d = inside(v.pos); + if v.color == egui::Color32::TRANSPARENT { + assert!((d + 0.5).abs() < 1e-2, "transparent vertex {d} from the edge"); + fringe += 1; + } else { + assert!(d > 0.5 - 1e-2, "solid vertex {d} from the edge"); + solid_edge += usize::from((d - 0.5).abs() < 1e-2); + } + } + assert!(fringe >= 48 && solid_edge >= 48, "{fringe} fringe, {solid_edge} edge vertices"); + // Every index points at a vertex. + assert!(m.indices.iter().all(|&i| (i as usize) < m.vertices.len())); + assert!(ring.indices.iter().all(|&i| (i as usize) < ring.vertices.len())); + assert!(triangle_mesh(tri, 0.25, 0.0).vertices.iter().all(|v| v.color.a() == 255)); +} + /// Picking a mode from the panel menu changes the panel; the theme never does. #[test] fn panel_menu_picks_the_mode_and_ramp() { diff --git a/crates/ui-egui/src/panels/color_panel_ui.rs b/crates/ui-egui/src/panels/color_panel_ui.rs index 798e24dea1..1ebd417309 100644 --- a/crates/ui-egui/src/panels/color_panel_ui.rs +++ b/crates/ui-egui/src/panels/color_panel_ui.rs @@ -568,9 +568,14 @@ fn wheel(app: &mut PhotocraftApp, ui: &mut egui::Ui) { let (center, inner, outer) = wheel_geometry(area); let ring_w = outer - inner; let (h, s, b) = (v[0] / 360.0, v[1] / 100.0, v[2] / 100.0); - ui.painter().add(ring_mesh(center, inner, outer)); + // Meshes aren't antialiased by egui: the ring and the triangle feather their own edges as + // egui's shapes do (#9996). + // Read outside the options' lock: asking the context for its scale inside it deadlocks. + let ppp = ui.ctx().pixels_per_point(); + let feather = ui.ctx().tessellation_options(|o| if o.feathering { o.feathering_size_in_pixels / ppp } else { 0.0 }); + ui.painter().add(ring_mesh(center, inner, outer, feather)); let tri = triangle(center, inner - 1.0, h); - ui.painter().add(triangle_mesh(tri, h)); + ui.painter().add(triangle_mesh(tri, h, feather)); // Which part a drag began on: the ring sets the hue, the triangle saturation and brightness. // The ring or the triangle, from where the press began (kept for frames without a press // origin), so a drag that leaves the ring keeps turning the hue. @@ -640,22 +645,29 @@ pub(crate) fn wheel_geometry(area: Rect) -> (Pos2, f32, f32) { (area.center(), outer - ring_w, outer) } -/// The wheel's hue ring between radii `inner` and `outer`. -fn ring_mesh(center: Pos2, inner: f32, outer: f32) -> Mesh { +/// The wheel's hue ring between radii `inner` and `outer`, its edges fading out over `feather` +/// points centred on them (0 for hard edges). +pub(crate) fn ring_mesh(center: Pos2, inner: f32, outer: f32, feather: f32) -> Mesh { let mut m = Mesh::default(); let steps = 96u32; + let half = feather / 2.0; + // Out from the centre: transparent, the hue, the hue, transparent (all the hue for hard edges). + let radii = [(inner - half).max(0.0), inner + half, outer - half, outer + half]; for k in 0..=steps { let f = k as f32 / steps as f32; let a = f * TAU; let c = rgb32(hsb_to_rgb([f * 360.0, 1.0, 1.0])); let dir = vec2(a.cos(), -a.sin()); - m.colored_vertex(center + dir * inner, c); - m.colored_vertex(center + dir * outer, c); + for (i, r) in radii.into_iter().enumerate() { + m.colored_vertex(center + dir * r, if feather > 0.0 && (i == 0 || i == 3) { Color32::TRANSPARENT } else { c }); + } } for k in 0..steps { - let a = k * 2; - m.add_triangle(a, a + 1, a + 3); - m.add_triangle(a, a + 3, a + 2); + for band in 0..3 { + let a = k * 4 + band; + m.add_triangle(a, a + 1, a + 5); + m.add_triangle(a, a + 5, a + 4); + } } m } @@ -694,14 +706,34 @@ pub(crate) fn triangle_sv([hue, white, black]: [Pos2; 3], p: Pos2) -> Option<(f3 Some((if b > 0.0 { bs / b } else { 0.0 }, b)) } -/// The triangle shaded through saturation and brightness at hue `h`. -fn triangle_mesh(tri: [Pos2; 3], h: f32) -> Mesh { +/// `tri` with every edge moved out by `d` (in by a negative `d`): scaled about its incentre, so +/// the point of a saturation and brightness moves with it. A degenerate triangle stays as it is. +fn offset_triangle(tri: [Pos2; 3], d: f32) -> [Pos2; 3] { + let [p, q, r] = tri; + // Each corner weighs by the length of the side opposite it. + let (a, b, c) = ((q - r).length(), (r - p).length(), (p - q).length()); + let perimeter = a + b + c; + let area2 = ((q - p).x * (r - p).y - (q - p).y * (r - p).x).abs(); + if perimeter <= 0.0 || area2 <= 1e-6 { + return tri; + } + let incentre = ((p.to_vec2() * a + q.to_vec2() * b + r.to_vec2() * c) / perimeter).to_pos2(); + let inradius = area2 / perimeter; + let k = ((inradius + d) / inradius).max(0.0); + tri.map(|v| incentre + (v - incentre) * k) +} + +/// The triangle shaded through saturation and brightness at hue `h`, its edges fading out over +/// `feather` points centred on them (0 for hard edges). +pub(crate) fn triangle_mesh(tri: [Pos2; 3], h: f32, feather: f32) -> Mesh { let n = 16usize; let mut m = Mesh::default(); + let (fill, fringe) = (offset_triangle(tri, -feather / 2.0), offset_triangle(tri, feather / 2.0)); + let color = |s: f32, b: f32| rgb32(hsb_to_rgb([h * 360.0, s, b])); for j in 0..=n { for i in 0..=n { let (s, b) = (i as f32 / n as f32, j as f32 / n as f32); - m.colored_vertex(triangle_point(tri, s, b), rgb32(hsb_to_rgb([h * 360.0, s, b]))); + m.colored_vertex(triangle_point(fill, s, b), color(s, b)); } } let row = (n + 1) as u32; @@ -712,6 +744,25 @@ fn triangle_mesh(tri: [Pos2; 3], h: f32) -> Mesh { m.add_triangle(a, a + row + 1, a + row); } } + if feather <= 0.0 { + return m; + } + // The edge, once round: black up to white (s = 0), white to the hue (b = 1), the hue down to + // black (s = 1). Each point gets a transparent twin on the larger triangle. + let t = |k: usize| k as f32 / n as f32; + let edge = (0..n).map(|k| (0.0, t(k))).chain((0..n).map(|k| (t(k), 1.0))).chain((0..n).map(|k| (1.0, t(n - k)))); + let start = m.vertices.len() as u32; + let mut count = 0u32; + for (s, b) in edge { + m.colored_vertex(triangle_point(fill, s, b), color(s, b)); + m.colored_vertex(triangle_point(fringe, s, b), Color32::TRANSPARENT); + count += 1; + } + for k in 0..count { + let (a, next) = (start + k * 2, start + (k + 1) % count * 2); + m.add_triangle(a, a + 1, next + 1); + m.add_triangle(a, next + 1, next); + } m } From d52a0a1051794c721fa20b3b86b5a8eb78d5de08 Mon Sep 17 00:00:00 2001 From: Taylor Burke Date: Wed, 28 Oct 2026 15:46:46 -0500 Subject: [PATCH 2/2] Color wheel: shade the feathered triangle by where picking reads it The solid part of the triangle is drawn half a feather in from its edges, but its vertices kept the saturation and brightness of their grid point, while picking and the knob read positions on the full triangle. Each vertex now takes its colour from `triangle_sv` at its drawn position, so what's shown is what's picked (CodeRabbit review on #10009). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01E8LSXezwgktJ1driAG4DoA --- crates/ui-egui/src/color_panel_tests.rs | 4 ++++ crates/ui-egui/src/panels/color_panel_ui.rs | 13 +++++++++---- 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/crates/ui-egui/src/color_panel_tests.rs b/crates/ui-egui/src/color_panel_tests.rs index c6ebe2a7cd..f23a326795 100644 --- a/crates/ui-egui/src/color_panel_tests.rs +++ b/crates/ui-egui/src/color_panel_tests.rs @@ -387,6 +387,10 @@ fn color_wheel_edges_are_feathered() { } else { assert!(d > 0.5 - 1e-2, "solid vertex {d} from the edge"); solid_edge += usize::from((d - 0.5).abs() < 1e-2); + // It shows the colour picking reads where it is drawn. + let (s, b) = crate::color_panel_ui::triangle_sv(tri, v.pos).unwrap(); + let picked = crate::color_panel_ui::rgb32(photocraft_color::convert::hsb_to_rgb([90.0, s, b])); + assert_eq!(v.color, picked, "vertex at {:?}", v.pos); } } assert!(fringe >= 48 && solid_edge >= 48, "{fringe} fringe, {solid_edge} edge vertices"); diff --git a/crates/ui-egui/src/panels/color_panel_ui.rs b/crates/ui-egui/src/panels/color_panel_ui.rs index 1ebd417309..29bf9bf83f 100644 --- a/crates/ui-egui/src/panels/color_panel_ui.rs +++ b/crates/ui-egui/src/panels/color_panel_ui.rs @@ -729,11 +729,16 @@ pub(crate) fn triangle_mesh(tri: [Pos2; 3], h: f32, feather: f32) -> Mesh { let n = 16usize; let mut m = Mesh::default(); let (fill, fringe) = (offset_triangle(tri, -feather / 2.0), offset_triangle(tri, feather / 2.0)); - let color = |s: f32, b: f32| rgb32(hsb_to_rgb([h * 360.0, s, b])); + // A vertex of the smaller triangle shows the colour picking reads at its position, which is + // on `tri`, so the drawn colour and the picked one agree. + let solid = |m: &mut Mesh, s: f32, b: f32| { + let p = triangle_point(fill, s, b); + let (s, b) = triangle_sv(tri, p).unwrap_or((s, b)); + m.colored_vertex(p, rgb32(hsb_to_rgb([h * 360.0, s, b]))); + }; for j in 0..=n { for i in 0..=n { - let (s, b) = (i as f32 / n as f32, j as f32 / n as f32); - m.colored_vertex(triangle_point(fill, s, b), color(s, b)); + solid(&mut m, i as f32 / n as f32, j as f32 / n as f32); } } let row = (n + 1) as u32; @@ -754,7 +759,7 @@ pub(crate) fn triangle_mesh(tri: [Pos2; 3], h: f32, feather: f32) -> Mesh { let start = m.vertices.len() as u32; let mut count = 0u32; for (s, b) in edge { - m.colored_vertex(triangle_point(fill, s, b), color(s, b)); + solid(&mut m, s, b); m.colored_vertex(triangle_point(fringe, s, b), Color32::TRANSPARENT); count += 1; }