parasyte
commented
1 year ago The way feathering is integrated into the tessellator makes it kind of difficult to control from the user side. As a quick test, I decided to try hacking the stroke methods to conditionally turn off feathering if the path is only composed of axis-aligned line segments:
diff --git a/crates/epaint/src/tessellator.rs b/crates/epaint/src/tessellator.rs
index a28daa60..66e3b634 100644
--- a/crates/epaint/src/tessellator.rs
+++ b/crates/epaint/src/tessellator.rs
@@ -474,18 +474,58 @@ impl Path {
/// Open-ended.
pub fn stroke_open(&self, feathering: f32, stroke: Stroke, out: &mut Mesh) {
+ let feathering = if self.is_axis_aligned(PathType::Open) {
+ 0.0
+ } else {
+ feathering
+ };
stroke_path(feathering, &self.0, PathType::Open, stroke, out);
}
/// A closed path (returning to the first point).
pub fn stroke_closed(&self, feathering: f32, stroke: Stroke, out: &mut Mesh) {
+ let feathering = if self.is_axis_aligned(PathType::Closed) {
+ 0.0
+ } else {
+ feathering
+ };
stroke_path(feathering, &self.0, PathType::Closed, stroke, out);
}
pub fn stroke(&self, feathering: f32, path_type: PathType, stroke: Stroke, out: &mut Mesh) {
+ let feathering = if self.is_axis_aligned(path_type) {
+ 0.0
+ } else {
+ feathering
+ };
stroke_path(feathering, &self.0, path_type, stroke, out);
}
+ fn is_axis_aligned(&self, path_type: PathType) -> bool {
+ let mut points = self.0.iter().peekable();
+
+ if let Some(point) = points.peek() {
+ let first_pos = point.pos;
+
+ while let Some(point) = points.next() {
+ let this_pos = point.pos;
+ let next_pos = match points.peek() {
+ None if path_type == PathType::Closed => first_pos,
+ None => break,
+ Some(point) => point.pos,
+ };
+
+ if this_pos.x != next_pos.x && this_pos.y != next_pos.y {
+ return false;
+ }
+ }
+
+ true
+ } else {
+ false
+ }
+ }
+
/// The path is taken to be closed (i.e. returning to the start again).
///
/// Calling this may reverse the vertices in the path if they are wrong winding order.For a simple patch, the results are ok:
Before:
After:
Compare these images in two tabs. The difference is subtle with GitHub's scaling.
One of the issues with this approach is that it ignores paths like rounded rectangles, which have long axis-aligned segments and very short non-aligned segments. You can see this in the window border on the "after" screenshot. It's shifted by a subpixel in each direction, so it appears thicker than the separator lines in the side bar.
A better approach would be selective feathering inside the stroke_path() function on a per-path-segment basis instead of the whole path.
Another issue with disabling any of the feathering is that some rendering looks much worse, like the bar chart plot in the demo app:
This happens, of course, because the bars are drawn right next to each other and whether or not the lines share the same pixel column depends on the scale of the Plot widget. You can adjust the window size until all of the lines overlap perfectly and then it looks nice. 😂 But that's a bad user experience.
cdobrescu
Is your feature request related to a problem? Please describe. I would like to be able to turn off antialiasing for a specific plot or even a chart inside the plot. Bar charts, which consist only of shapes composed from vertical and horizontal lines, have a crispier pixel perfect look when antialiasing is disabled. Antialiased:
Pixel perfect:
Also, the gridlines look a lot better without antialiasing
Describe the solution you'd like I'm not sure what's the best API change for this would be:
Describe alternatives you've considered I tried turning it off inside a function that creates the chart:
and turn it back later after the shapes were added to the draw list. But I think that shape creation and drawing are async so the final result was still showing everything antialiased.