Added ability to define colors at UV coordinates along a path

crates/egui/src/painter.rs

@@ -7,7 +7,7 @@ use crate::{
 };
 use epaint::{
     text::{Fonts, Galley, LayoutJob},
-    CircleShape, ClippedShape, RectShape, Rounding, Shape, Stroke,
+    CircleShape, ClippedShape, PathStroke, RectShape, Rounding, Shape, Stroke,
 };
 
 /// Helper to paint shapes and text to a specific region on a specific layer.
@@ -280,21 +280,21 @@ impl Painter {
 /// # Paint different primitives
 impl Painter {
     /// Paints a line from the first point to the second.
-    pub fn line_segment(&self, points: [Pos2; 2], stroke: impl Into<Stroke>) -> ShapeIdx {
+    pub fn line_segment(&self, points: [Pos2; 2], stroke: impl Into<PathStroke>) -> ShapeIdx {
         self.add(Shape::LineSegment {
             points,
             stroke: stroke.into(),
         })
     }
 
     /// Paints a horizontal line.
-    pub fn hline(&self, x: impl Into<Rangef>, y: f32, stroke: impl Into<Stroke>) -> ShapeIdx {
-        self.add(Shape::hline(x, y, stroke))
+    pub fn hline(&self, x: impl Into<Rangef>, y: f32, stroke: impl Into<PathStroke>) -> ShapeIdx {
+        self.add(Shape::hline(x, y, stroke.into()))
     }
 
     /// Paints a vertical line.
-    pub fn vline(&self, x: f32, y: impl Into<Rangef>, stroke: impl Into<Stroke>) -> ShapeIdx {
-        self.add(Shape::vline(x, y, stroke))
+    pub fn vline(&self, x: f32, y: impl Into<Rangef>, stroke: impl Into<PathStroke>) -> ShapeIdx {
+        self.add(Shape::vline(x, y, stroke.into()))
     }
 
     pub fn circle(
@@ -513,15 +513,15 @@ impl Painter {
 }
 
 fn tint_shape_towards(shape: &mut Shape, target: Color32) {
-    epaint::shape_transform::adjust_colors(shape, &|color| {
+    epaint::shape_transform::adjust_colors(shape, move |color| {
         if *color != Color32::PLACEHOLDER {
             *color = crate::ecolor::tint_color_towards(*color, target);
         }
     });
 }
 
 fn multiply_opacity(shape: &mut Shape, opacity: f32) {
-    epaint::shape_transform::adjust_colors(shape, &|color| {
+    epaint::shape_transform::adjust_colors(shape, move |color| {
         if *color != Color32::PLACEHOLDER {
             *color = color.gamma_multiply(opacity);
         }

crates/egui_demo_lib/Cargo.toml

@@ -50,6 +50,9 @@ chrono = { version = "0.4", optional = true, features = ["js-sys", "wasmbind"] }
 ## Enable this when generating docs.
 document-features = { workspace = true, optional = true }
 serde = { version = "1", optional = true, features = ["derive"] }
+once_cell = "1.19"
+colorgrad = "0.6"
+noise = "0.9"
 
 
 [dev-dependencies]

crates/egui_demo_lib/src/demo/dancing_trans_strings.rs

@@ -0,0 +1,90 @@
+use colorgrad::{Color, CustomGradient, Gradient};
+use egui::{containers::*, epaint::PathStroke, *};
+use noise::{NoiseFn, OpenSimplex};
+use once_cell::sync::Lazy;
+
+static GRADIENT: Lazy<Gradient> = Lazy::new(|| {
+    CustomGradient::new()
+        .colors(&[
+            Color::from_html("#5BCEFA").unwrap(),
+            Color::from_html("#F5A9B8").unwrap(),
+            Color::from_html("#FFFFFF").unwrap(),
+            Color::from_html("#F5A9B8").unwrap(),
+            Color::from_html("#5BCEFA").unwrap(),
+        ])
+        .build()
+        .unwrap_or(colorgrad::rainbow())
+});
+static NOISE: Lazy<OpenSimplex> = Lazy::new(|| OpenSimplex::new(6940));
+
+#[derive(Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct DancingStrings {}
+
+impl super::Demo for DancingStrings {
+    fn name(&self) -> &'static str {
+        "♫ Dancing Strings (Colored)"
+    }
+
+    fn show(&mut self, ctx: &Context, open: &mut bool) {
+        use super::View as _;
+        Window::new(self.name())
+            .open(open)
+            .default_size(vec2(512.0, 256.0))
+            .vscroll(false)
+            .show(ctx, |ui| self.ui(ui));
+    }
+}
+
+impl super::View for DancingStrings {
+    fn ui(&mut self, ui: &mut Ui) {
+        Frame::canvas(ui.style()).show(ui, |ui| {
+            ui.ctx().request_repaint();
+            let time = ui.input(|i| i.time);
+
+            let desired_size = ui.available_width() * vec2(1.0, 0.35);
+            let (_id, rect) = ui.allocate_space(desired_size);
+
+            let to_screen =
+                emath::RectTransform::from_to(Rect::from_x_y_ranges(0.0..=1.0, -1.0..=1.0), rect);
+
+            let mut shapes = vec![];
+
+            for &mode in &[2, 3, 5] {
+                let mode = mode as f64;
+                let n = 120;
+                let speed = 1.5;
+
+                let points: Vec<Pos2> = (0..=n)
+                    .map(|i| {
+                        let t = i as f64 / (n as f64);
+                        let amp = (time * speed * mode).sin() / mode;
+                        let y = amp * (t * std::f64::consts::TAU / 2.0 * mode).sin();
+                        to_screen * pos2(t as f32, y as f32)
+                    })
+                    .collect();
+
+                let thickness = 10.0 / mode as f32;
+                shapes.push(epaint::Shape::line(
+                    points,
+                    PathStroke::new_uv(thickness, move |_r, p| {
+                        let time = time / 10.0;
+                        let x = remap(p.x, rect.x_range(), 0.0..=1.0) as f64;
+                        let y = remap(p.y, rect.y_range(), 0.0..=1.0) as f64;
+
+                        let noise = NOISE.get([x * 1.25 + time, y * 1.25 + time]);
+                        let color = GRADIENT.at(noise).to_rgba8();
+
+                        Color32::from_rgba_premultiplied(color[0], color[1], color[2], color[3])
+                    }),
+                ));
+            }
+
+            ui.painter().extend(shapes);
+        });
+        ui.vertical_centered(|ui| {
+            ui.add(crate::egui_github_link_file!());
+        });
+    }
+}

crates/egui_demo_lib/src/demo/demo_app_windows.rs

@@ -26,6 +26,7 @@ impl Default for Demos {
             Box::<super::code_example::CodeExample>::default(),
             Box::<super::context_menu::ContextMenus>::default(),
             Box::<super::dancing_strings::DancingStrings>::default(),
+            Box::<super::dancing_trans_strings::DancingStrings>::default(),
             Box::<super::drag_and_drop::DragAndDropDemo>::default(),
             Box::<super::extra_viewport::ExtraViewport>::default(),
             Box::<super::font_book::FontBook>::default(),

crates/egui_demo_lib/src/demo/mod.rs

@@ -9,6 +9,7 @@ pub mod code_editor;
 pub mod code_example;
 pub mod context_menu;
 pub mod dancing_strings;
+pub mod dancing_trans_strings;
 pub mod demo_app_windows;
 pub mod drag_and_drop;
 pub mod extra_viewport;

crates/epaint/benches/benchmark.rs

@@ -1,6 +1,6 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
-use epaint::*;
+use epaint::{tessellator::Path, *};
 
 fn single_dashed_lines(c: &mut Criterion) {
     c.bench_function("single_dashed_lines", move |b| {
@@ -72,10 +72,74 @@ fn tessellate_circles(c: &mut Criterion) {
     });
 }
 
+fn thick_line_solid(c: &mut Criterion) {
+    c.bench_function("thick_solid_line", move |b| {
+        let line = [pos2(0.0, 0.0), pos2(50.0, 0.0), pos2(100.0, 1.0)];
+        let mut path = Path::default();
+        path.add_open_points(&line);
+
+        b.iter(|| {
+            let mut mesh = Mesh::default();
+            path.stroke_closed(1.5, &Stroke::new(2.0, Color32::RED).into(), &mut mesh);
+
+            black_box(mesh);
+        });
+    });
+}
+
+fn thick_large_line_solid(c: &mut Criterion) {
+    c.bench_function("thick_large_solid_line", move |b| {
+        let line = (0..1000).map(|i| pos2(i as f32, 10.0)).collect::<Vec<_>>();
+        let mut path = Path::default();
+        path.add_open_points(&line);
+
+        b.iter(|| {
+            let mut mesh = Mesh::default();
+            path.stroke_closed(1.5, &Stroke::new(2.0, Color32::RED).into(), &mut mesh);
+
+            black_box(mesh);
+        });
+    });
+}
+
+fn thin_line_solid(c: &mut Criterion) {
+    c.bench_function("thin_solid_line", move |b| {
+        let line = [pos2(0.0, 0.0), pos2(50.0, 0.0), pos2(100.0, 1.0)];
+        let mut path = Path::default();
+        path.add_open_points(&line);
+
+        b.iter(|| {
+            let mut mesh = Mesh::default();
+            path.stroke_closed(1.5, &Stroke::new(0.5, Color32::RED).into(), &mut mesh);
+
+            black_box(mesh);
+        });
+    });
+}
+
+fn thin_large_line_solid(c: &mut Criterion) {
+    c.bench_function("thin_large_solid_line", move |b| {
+        let line = (0..1000).map(|i| pos2(i as f32, 10.0)).collect::<Vec<_>>();
+        let mut path = Path::default();
+        path.add_open_points(&line);
+
+        b.iter(|| {
+            let mut mesh = Mesh::default();
+            path.stroke_closed(1.5, &Stroke::new(0.5, Color32::RED).into(), &mut mesh);
+
+            black_box(mesh);
+        });
+    });
+}
+
 criterion_group!(
     benches,
     single_dashed_lines,
     many_dashed_lines,
-    tessellate_circles
+    tessellate_circles,
+    thick_line_solid,
+    thick_large_line_solid,
+    thin_line_solid,
+    thin_large_line_solid
 );
 criterion_main!(benches);