Merge branch 'master' into vello_cpu

Author: hecrj

Cargo.toml

@@ -120,12 +120,18 @@ image.optional = true
 [dev-dependencies]
 criterion = "0.5"
 iced_wgpu.workspace = true
+iced_renderer.workspace = true
 
 [[bench]]
 name = "wgpu"
 harness = false
 required-features = ["canvas"]
 
+[[bench]]
+name = "cpu"
+harness = false
+required-features = ["canvas"]
+
 [profile.release-opt]
 inherits = "release"
 codegen-units = 1

benches/cpu.rs

@@ -0,0 +1,142 @@
+#![allow(missing_docs)]
+use criterion::{Bencher, Criterion, criterion_group, criterion_main};
+
+use iced::border;
+use iced::mouse;
+use iced::widget::{canvas, center_y, column, container, row, scrollable, space, text};
+use iced::{Center, Color, Element, Fill, Length, Never, Point, Rectangle, Size, Theme};
+use iced_renderer::Renderer;
+use iced_renderer::core::renderer::{self, Headless as _};
+use iced_runtime::UserInterface;
+use iced_runtime::user_interface;
+
+use iced_futures::futures::executor;
+
+criterion_main!(benches);
+criterion_group!(benches, benchmark);
+
+const VIEWPORT: Size<f32> = Size::new(512.0, 512.0);
+const SCALE: f32 = 2.0;
+
+pub fn benchmark(c: &mut Criterion) {
+    let mut renderer = executor::block_on(Renderer::new(
+        renderer::Settings::default(),
+        Some("software"),
+    ))
+    .expect("software renderer must be available");
+
+    let _ = c
+        .bench_function("cpu — ipsum", |b| {
+            draw(b, &mut renderer, ipsum());
+        })
+        .bench_function("cpu — application", |b| {
+            draw(b, &mut renderer, application());
+        });
+}
+
+fn draw(bencher: &mut Bencher<'_>, renderer: &mut Renderer, view: Element<'static, Never>) {
+    let mut ui = UserInterface::build(view, VIEWPORT, user_interface::Cache::new(), renderer);
+
+    bencher.iter(|| {
+        ui.draw(
+            renderer,
+            &Theme::Dark,
+            &renderer::Style::default(),
+            mouse::Cursor::Unavailable,
+        );
+
+        let _ = renderer.screenshot(
+            Size::new(
+                (VIEWPORT.width * SCALE) as u32,
+                (VIEWPORT.height * SCALE) as u32,
+            ),
+            SCALE,
+            Color::WHITE,
+        );
+    });
+}
+
+fn ipsum() -> Element<'static, Never> {
+    text(include_str!("ipsum.txt"))
+        .ellipsis(text::Ellipsis::End)
+        .into()
+}
+
+fn application() -> Element<'static, Never> {
+    fn square<'a>(size: impl Into<Length> + Copy) -> Element<'a, Never> {
+        struct Square;
+
+        impl canvas::Program<Never> for Square {
+            type State = ();
+
+            fn draw(
+                &self,
+                _state: &Self::State,
+                renderer: &Renderer,
+                theme: &Theme,
+                bounds: Rectangle,
+                _cursor: mouse::Cursor,
+            ) -> Vec<canvas::Geometry> {
+                let mut frame = canvas::Frame::new(renderer, bounds.size());
+
+                let palette = theme.palette();
+
+                frame.fill_rectangle(
+                    Point::ORIGIN,
+                    bounds.size(),
+                    palette.background.strong.color,
+                );
+
+                vec![frame.into_geometry()]
+            }
+        }
+
+        canvas(Square).width(size).height(size).into()
+    }
+
+    let header = container(
+        row![
+            square(40),
+            space::horizontal(),
+            "Header!",
+            space::horizontal(),
+            square(40),
+        ]
+        .padding(10)
+        .align_y(Center),
+    )
+    .style(|theme| {
+        let palette = theme.palette();
+
+        container::Style::default().border(border::color(palette.background.strong.color).width(1))
+    });
+
+    let sidebar = center_y(
+        column!["Sidebar!", square(50), square(50)]
+            .spacing(40)
+            .padding(10)
+            .width(200)
+            .align_x(Center),
+    )
+    .style(container::rounded_box);
+
+    let content = container(
+        scrollable(
+            column![
+                "Content!",
+                row((1..10).map(|i| square(if i % 2 == 0 { 80 } else { 160 })))
+                    .spacing(20)
+                    .align_y(Center)
+                    .wrap(),
+                "The end"
+            ]
+            .spacing(40)
+            .align_x(Center)
+            .width(Fill),
+        )
+        .height(Fill),
+    )
+    .padding(10);
+
+    column![header, row![sidebar, content]].into()
+}

benches/wgpu.rs

@@ -11,7 +11,6 @@ use iced_wgpu::wgpu;
 criterion_main!(benches);
 criterion_group!(benches, wgpu_benchmark);
 
-#[allow(unused_results)]
 pub fn wgpu_benchmark(c: &mut Criterion) {
     use iced_futures::futures::executor;
     use iced_wgpu::wgpu;
@@ -38,35 +37,33 @@ pub fn wgpu_benchmark(c: &mut Criterion) {
     }))
     .expect("request device");
 
-    c.bench_function("wgpu — canvas (light)", |b| {
-        benchmark(b, &adapter, &device, &queue, |_| scene(10));
-    });
-    c.bench_function("wgpu — canvas (heavy)", |b| {
-        benchmark(b, &adapter, &device, &queue, |_| scene(1_000));
-    });
-
-    c.bench_function("wgpu - layered text (light)", |b| {
-        benchmark(b, &adapter, &device, &queue, |_| layered_text(10));
-    });
-    c.bench_function("wgpu - layered text (heavy)", |b| {
-        benchmark(b, &adapter, &device, &queue, |_| layered_text(1_000));
-    });
-
-    c.bench_function("wgpu - dynamic text (light)", |b| {
-        benchmark(b, &adapter, &device, &queue, |i| dynamic_text(1_000, i));
-    });
-    c.bench_function("wgpu - dynamic text (heavy)", |b| {
-        benchmark(b, &adapter, &device, &queue, |i| dynamic_text(100_000, i));
-    });
-
-    c.bench_function("wgpu - advanced shaping (light)", |b| {
-        benchmark(b, &adapter, &device, &queue, |i| advanced_shaping(1_000, i));
-    });
-    c.bench_function("wgpu - advanced shaping (heavy)", |b| {
-        benchmark(b, &adapter, &device, &queue, |i| {
-            advanced_shaping(100_000, i)
+    let _ = c
+        .bench_function("wgpu — canvas (light)", |b| {
+            benchmark(b, &adapter, &device, &queue, |_| scene(10));
+        })
+        .bench_function("wgpu — canvas (heavy)", |b| {
+            benchmark(b, &adapter, &device, &queue, |_| scene(1_000));
+        })
+        .bench_function("wgpu - layered text (light)", |b| {
+            benchmark(b, &adapter, &device, &queue, |_| layered_text(10));
+        })
+        .bench_function("wgpu - layered text (heavy)", |b| {
+            benchmark(b, &adapter, &device, &queue, |_| layered_text(1_000));
+        })
+        .bench_function("wgpu - dynamic text (light)", |b| {
+            benchmark(b, &adapter, &device, &queue, |i| dynamic_text(1_000, i));
+        })
+        .bench_function("wgpu - dynamic text (heavy)", |b| {
+            benchmark(b, &adapter, &device, &queue, |i| dynamic_text(100_000, i));
+        })
+        .bench_function("wgpu - advanced shaping (light)", |b| {
+            benchmark(b, &adapter, &device, &queue, |i| advanced_shaping(1_000, i));
+        })
+        .bench_function("wgpu - advanced shaping (heavy)", |b| {
+            benchmark(b, &adapter, &device, &queue, |i| {
+                advanced_shaping(100_000, i)
+            });
         });
-    });
 }
 
 fn benchmark<'a>(

examples/loupe/src/main.rs

@@ -47,11 +47,12 @@ impl Loupe {
 
 mod loupe {
     use iced::advanced::Renderer as _;
+    use iced::advanced::Shell;
     use iced::advanced::layout::{self, Layout};
     use iced::advanced::renderer;
     use iced::advanced::widget::{self, Widget};
     use iced::mouse;
-    use iced::{Color, Element, Length, Rectangle, Renderer, Size, Theme, Transformation};
+    use iced::{Color, Element, Event, Length, Rectangle, Renderer, Size, Theme, Transformation};
 
     pub fn loupe<'a, Message>(
         zoom: f32,
@@ -101,6 +102,21 @@ mod loupe {
             self.content.as_widget_mut().layout(tree, renderer, limits)
         }
 
+        fn update(
+            &mut self,
+            _tree: &mut widget::Tree,
+            _event: &Event,
+            layout: Layout<'_>,
+            cursor: mouse::Cursor,
+            _renderer: &Renderer,
+            shell: &mut Shell<'_, Message>,
+            _viewport: &Rectangle,
+        ) {
+            if cursor.is_over(layout.bounds().expand(10)) {
+                shell.request_redraw();
+            }
+        }
+
         fn draw(
             &self,
             tree: &widget::Tree,

graphics/src/layer.rs

@@ -156,13 +156,14 @@ impl<T: Layer> Stack<T> {
 
             // We scan downwards for a contiguous block of mergeable layer candidates
             while current > 0 {
-                let candidate = &self.layers[current - 1];
+                current -= 1;
+
+                let candidate = &self.layers[current];
                 let start = candidate.start();
                 let end = candidate.end();
 
                 // We skip empty layers
                 if end == 0 {
-                    current -= 1;
                     continue;
                 }
 
@@ -176,7 +177,6 @@ impl<T: Layer> Stack<T> {
                 target = candidate;
                 target_start = start;
                 target_index = current;
-                current -= 1;
             }
 
             // We merge all the layers scanned into the target

graphics/src/text.rs

@@ -260,7 +260,7 @@ pub fn align(
 
             needs_relayout = true;
         } else if let Some(line) = buffer.lines.first_mut() {
-            needs_relayout = line.set_align(None);
+            needs_relayout |= line.set_align(None);
         }
     }
 

widget/src/pane_grid.rs

@@ -719,13 +719,9 @@ where
         let node = self.internal.layout();
         let resize_leeway = self.on_resize.as_ref().map(|(leeway, _)| *leeway);
 
-        let picked_pane = action.picked_pane().filter(|(_, origin)| {
-            cursor
-                .position()
-                .map(|position| position.distance(*origin))
-                .unwrap_or_default()
-                > DRAG_DEADBAND_DISTANCE
-        });
+        let picked_pane = action.picked_pane();
+        let dragged_pane = picked_pane
+            .filter(|(_, origin)| is_dragging(*origin, cursor.position().unwrap_or_default()));
 
         let picked_split = action
             .picked_split()
@@ -800,11 +796,10 @@ where
                         viewport,
                     );
 
-                    if picked_pane.is_some()
+                    if let Some(cursor_position) = cursor.position()
+                        && dragged_pane.is_some()
                         && pane_in_edge.is_none()
-                        && let Some(region) = cursor
-                            .position()
-                            .and_then(|cursor_position| layout_region(pane_layout, cursor_position))
+                        && let Some(region) = layout_region(pane_layout, cursor_position)
                     {
                         let bounds = layout_region_bounds(pane_layout, region);
 
@@ -832,7 +827,9 @@ where
             }
         }
 
-        if let Some(edge) = pane_in_edge {
+        if dragged_pane.is_some()
+            && let Some(edge) = pane_in_edge
+        {
             let bounds = edge_bounds(layout, edge);
 
             renderer.fill_quad(
@@ -845,7 +842,7 @@ where
             );
         }
 
-        if picked_pane.is_none()
+        if dragged_pane.is_none()
             && let Some((axis, split_region, is_picked)) = picked_split
         {
             let highlight = if is_picked {
@@ -955,8 +952,13 @@ where
         _layout: Layout<'_>,
         cursor: mouse::Cursor,
     ) {
-        let translation =
-            cursor.position().unwrap_or_default() - Point::new(self.origin.x, self.origin.y);
+        let cursor_position = cursor.position().unwrap_or_default();
+
+        let translation = if is_dragging(self.origin, cursor_position) {
+            cursor_position - self.origin
+        } else {
+            Vector::ZERO
+        };
 
         renderer.with_translation(translation, |renderer| {
             self.content.draw(
@@ -972,6 +974,10 @@ where
     }
 }
 
+fn is_dragging(origin: Point, cursor: Point) -> bool {
+    cursor.distance(origin) > DRAG_DEADBAND_DISTANCE
+}
+
 impl<'a, Message, Theme, Renderer> From<PaneGrid<'a, Message, Theme, Renderer>>
     for Element<'a, Message, Theme, Renderer>
 where

widget/src/pane_grid/state.rs

@@ -424,7 +424,7 @@ pub enum Action {
 }
 
 impl Action {
-    /// Returns the current [`Pane`] that is being dragged, if any.
+    /// Returns the current [`Pane`] that is being picked, if any.
     pub fn picked_pane(&self) -> Option<(Pane, Point)> {
         match *self {
             Action::Dragging { pane, origin, .. } => Some((pane, origin)),