summaryrefslogtreecommitdiffstats
path: root/examples
diff options
context:
space:
mode:
Diffstat (limited to 'examples')
-rw-r--r--examples/README.md2
-rw-r--r--examples/bezier_tool/Cargo.toml5
-rw-r--r--examples/bezier_tool/README.md3
-rw-r--r--examples/bezier_tool/src/main.rs466
-rw-r--r--examples/clock/Cargo.toml3
-rw-r--r--examples/clock/src/main.rs101
-rw-r--r--examples/custom_widget/src/main.rs2
-rw-r--r--examples/geometry/src/main.rs111
-rw-r--r--examples/integration/src/main.rs2
-rw-r--r--examples/solar_system/Cargo.toml3
-rw-r--r--examples/solar_system/src/main.rs187
11 files changed, 375 insertions, 510 deletions
diff --git a/examples/README.md b/examples/README.md
index 5aea51eb..5d880d71 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -69,7 +69,7 @@ cargo run --package styling
## Extras
A bunch of simpler examples exist:
-- [`bezier_tool`](bezier_tool), a Paint-like tool for drawing Bézier curves using [`lyon`].
+- [`bezier_tool`](bezier_tool), a Paint-like tool for drawing Bézier curves using the `Canvas` widget.
- [`clock`](clock), an application that uses the `Canvas` widget to draw a clock and its hands to display the current time.
- [`counter`](counter), the classic counter example explained in the [`README`](../README.md).
- [`custom_widget`](custom_widget), a demonstration of how to build a custom widget that draws a circle.
diff --git a/examples/bezier_tool/Cargo.toml b/examples/bezier_tool/Cargo.toml
index b13a0aa5..a88975a7 100644
--- a/examples/bezier_tool/Cargo.toml
+++ b/examples/bezier_tool/Cargo.toml
@@ -6,7 +6,4 @@ edition = "2018"
publish = false
[dependencies]
-iced = { path = "../.." }
-iced_native = { path = "../../native" }
-iced_wgpu = { path = "../../wgpu" }
-lyon = "0.15"
+iced = { path = "../..", features = ["canvas"] }
diff --git a/examples/bezier_tool/README.md b/examples/bezier_tool/README.md
index 933f2120..ebbb12cc 100644
--- a/examples/bezier_tool/README.md
+++ b/examples/bezier_tool/README.md
@@ -1,6 +1,6 @@
## Bézier tool
-A Paint-like tool for drawing Bézier curves using [`lyon`].
+A Paint-like tool for drawing Bézier curves using the `Canvas` widget.
The __[`main`]__ file contains all the code of the example.
@@ -16,4 +16,3 @@ cargo run --package bezier_tool
```
[`main`]: src/main.rs
-[`lyon`]: https://github.com/nical/lyon
diff --git a/examples/bezier_tool/src/main.rs b/examples/bezier_tool/src/main.rs
index fcb7733c..6473db75 100644
--- a/examples/bezier_tool/src/main.rs
+++ b/examples/bezier_tool/src/main.rs
@@ -1,291 +1,6 @@
-//! This example showcases a simple native custom widget that renders arbitrary
-//! path with `lyon`.
-mod bezier {
- // For now, to implement a custom native widget you will need to add
- // `iced_native` and `iced_wgpu` to your dependencies.
- //
- // Then, you simply need to define your widget type and implement the
- // `iced_native::Widget` trait with the `iced_wgpu::Renderer`.
- //
- // Of course, you can choose to make the implementation renderer-agnostic,
- // if you wish to, by creating your own `Renderer` trait, which could be
- // implemented by `iced_wgpu` and other renderers.
- use iced_native::{
- input, layout, Clipboard, Color, Element, Event, Font, Hasher,
- HorizontalAlignment, Layout, Length, MouseCursor, Point, Rectangle,
- Size, Vector, VerticalAlignment, Widget,
- };
- use iced_wgpu::{
- triangle::{Mesh2D, Vertex2D},
- Defaults, Primitive, Renderer,
- };
- use lyon::tessellation::{
- basic_shapes, BuffersBuilder, StrokeAttributes, StrokeOptions,
- StrokeTessellator, VertexBuffers,
- };
-
- pub struct Bezier<'a, Message> {
- state: &'a mut State,
- curves: &'a [Curve],
- // [from, to, ctrl]
- on_click: Box<dyn Fn(Curve) -> Message>,
- }
-
- #[derive(Debug, Clone, Copy)]
- pub struct Curve {
- from: Point,
- to: Point,
- control: Point,
- }
-
- #[derive(Default)]
- pub struct State {
- pending: Option<Pending>,
- }
-
- enum Pending {
- One { from: Point },
- Two { from: Point, to: Point },
- }
-
- impl<'a, Message> Bezier<'a, Message> {
- pub fn new<F>(
- state: &'a mut State,
- curves: &'a [Curve],
- on_click: F,
- ) -> Self
- where
- F: 'static + Fn(Curve) -> Message,
- {
- Self {
- state,
- curves,
- on_click: Box::new(on_click),
- }
- }
- }
-
- impl<'a, Message> Widget<Message, Renderer> for Bezier<'a, Message> {
- fn width(&self) -> Length {
- Length::Fill
- }
-
- fn height(&self) -> Length {
- Length::Fill
- }
-
- fn layout(
- &self,
- _renderer: &Renderer,
- limits: &layout::Limits,
- ) -> layout::Node {
- let size = limits
- .height(Length::Fill)
- .width(Length::Fill)
- .resolve(Size::ZERO);
- layout::Node::new(size)
- }
-
- fn draw(
- &self,
- _renderer: &mut Renderer,
- defaults: &Defaults,
- layout: Layout<'_>,
- cursor_position: Point,
- ) -> (Primitive, MouseCursor) {
- let mut buffer: VertexBuffers<Vertex2D, u32> = VertexBuffers::new();
- let mut path_builder = lyon::path::Path::builder();
-
- let bounds = layout.bounds();
-
- // Draw rectangle border with lyon.
- basic_shapes::stroke_rectangle(
- &lyon::math::Rect::new(
- lyon::math::Point::new(0.5, 0.5),
- lyon::math::Size::new(
- bounds.width - 1.0,
- bounds.height - 1.0,
- ),
- ),
- &StrokeOptions::default().with_line_width(1.0),
- &mut BuffersBuilder::new(
- &mut buffer,
- |pos: lyon::math::Point, _: StrokeAttributes| Vertex2D {
- position: pos.to_array(),
- color: [0.0, 0.0, 0.0, 1.0],
- },
- ),
- )
- .unwrap();
-
- for curve in self.curves {
- path_builder.move_to(lyon::math::Point::new(
- curve.from.x,
- curve.from.y,
- ));
-
- path_builder.quadratic_bezier_to(
- lyon::math::Point::new(curve.control.x, curve.control.y),
- lyon::math::Point::new(curve.to.x, curve.to.y),
- );
- }
-
- match self.state.pending {
- None => {}
- Some(Pending::One { from }) => {
- path_builder
- .move_to(lyon::math::Point::new(from.x, from.y));
- path_builder.line_to(lyon::math::Point::new(
- cursor_position.x - bounds.x,
- cursor_position.y - bounds.y,
- ));
- }
- Some(Pending::Two { from, to }) => {
- path_builder
- .move_to(lyon::math::Point::new(from.x, from.y));
- path_builder.quadratic_bezier_to(
- lyon::math::Point::new(
- cursor_position.x - bounds.x,
- cursor_position.y - bounds.y,
- ),
- lyon::math::Point::new(to.x, to.y),
- );
- }
- }
-
- let mut tessellator = StrokeTessellator::new();
-
- // Draw strokes with lyon.
- tessellator
- .tessellate(
- &path_builder.build(),
- &StrokeOptions::default().with_line_width(3.0),
- &mut BuffersBuilder::new(
- &mut buffer,
- |pos: lyon::math::Point, _: StrokeAttributes| {
- Vertex2D {
- position: pos.to_array(),
- color: [0.0, 0.0, 0.0, 1.0],
- }
- },
- ),
- )
- .unwrap();
-
- let mesh = Primitive::Mesh2D {
- origin: Point::new(bounds.x, bounds.y),
- buffers: Mesh2D {
- vertices: buffer.vertices,
- indices: buffer.indices,
- },
- };
-
- (
- Primitive::Clip {
- bounds,
- offset: Vector::new(0, 0),
- content: Box::new(
- if self.curves.is_empty()
- && self.state.pending.is_none()
- {
- let instructions = Primitive::Text {
- bounds: Rectangle {
- x: bounds.center_x(),
- y: bounds.center_y(),
- ..bounds
- },
- color: Color {
- a: defaults.text.color.a * 0.7,
- ..defaults.text.color
- },
- content: String::from(
- "Click to create bezier curves!",
- ),
- font: Font::Default,
- size: 30.0,
- horizontal_alignment:
- HorizontalAlignment::Center,
- vertical_alignment: VerticalAlignment::Center,
- };
-
- Primitive::Group {
- primitives: vec![mesh, instructions],
- }
- } else {
- mesh
- },
- ),
- },
- MouseCursor::OutOfBounds,
- )
- }
-
- fn hash_layout(&self, _state: &mut Hasher) {}
-
- fn on_event(
- &mut self,
- event: Event,
- layout: Layout<'_>,
- cursor_position: Point,
- messages: &mut Vec<Message>,
- _renderer: &Renderer,
- _clipboard: Option<&dyn Clipboard>,
- ) {
- let bounds = layout.bounds();
-
- if bounds.contains(cursor_position) {
- match event {
- Event::Mouse(input::mouse::Event::Input {
- state: input::ButtonState::Pressed,
- ..
- }) => {
- let new_point = Point::new(
- cursor_position.x - bounds.x,
- cursor_position.y - bounds.y,
- );
-
- match self.state.pending {
- None => {
- self.state.pending =
- Some(Pending::One { from: new_point });
- }
- Some(Pending::One { from }) => {
- self.state.pending = Some(Pending::Two {
- from,
- to: new_point,
- });
- }
- Some(Pending::Two { from, to }) => {
- self.state.pending = None;
-
- messages.push((self.on_click)(Curve {
- from,
- to,
- control: new_point,
- }));
- }
- }
- }
- _ => {}
- }
- }
- }
- }
-
- impl<'a, Message> Into<Element<'a, Message, Renderer>> for Bezier<'a, Message>
- where
- Message: 'static,
- {
- fn into(self) -> Element<'a, Message, Renderer> {
- Element::new(self)
- }
- }
-}
-
-use bezier::Bezier;
+//! This example showcases an interactive `Canvas` for drawing Bézier curves.
use iced::{
- button, Align, Button, Column, Container, Element, Length, Sandbox,
- Settings, Text,
+ button, Align, Button, Column, Element, Length, Sandbox, Settings, Text,
};
pub fn main() {
@@ -323,6 +38,7 @@ impl Sandbox for Example {
match message {
Message::AddCurve(curve) => {
self.curves.push(curve);
+ self.bezier.request_redraw();
}
Message::Clear => {
self.bezier = bezier::State::default();
@@ -332,7 +48,7 @@ impl Sandbox for Example {
}
fn view(&mut self) -> Element<Message> {
- let content = Column::new()
+ Column::new()
.padding(20)
.spacing(20)
.align_items(Align::Center)
@@ -341,22 +57,178 @@ impl Sandbox for Example {
.width(Length::Shrink)
.size(50),
)
- .push(Bezier::new(
- &mut self.bezier,
- self.curves.as_slice(),
- Message::AddCurve,
- ))
+ .push(self.bezier.view(&self.curves).map(Message::AddCurve))
.push(
Button::new(&mut self.button_state, Text::new("Clear"))
.padding(8)
.on_press(Message::Clear),
- );
+ )
+ .into()
+ }
+}
- Container::new(content)
+mod bezier {
+ use iced::{
+ canvas::{self, Canvas, Cursor, Event, Frame, Geometry, Path, Stroke},
+ mouse, ButtonState, Element, Length, MouseCursor, Point, Rectangle,
+ };
+
+ #[derive(Default)]
+ pub struct State {
+ pending: Option<Pending>,
+ cache: canvas::Cache,
+ }
+
+ impl State {
+ pub fn view<'a>(
+ &'a mut self,
+ curves: &'a [Curve],
+ ) -> Element<'a, Curve> {
+ Canvas::new(Bezier {
+ state: self,
+ curves,
+ })
.width(Length::Fill)
.height(Length::Fill)
- .center_x()
- .center_y()
.into()
+ }
+
+ pub fn request_redraw(&mut self) {
+ self.cache.clear()
+ }
+ }
+
+ struct Bezier<'a> {
+ state: &'a mut State,
+ curves: &'a [Curve],
+ }
+
+ impl<'a> canvas::Program<Curve> for Bezier<'a> {
+ fn update(
+ &mut self,
+ event: Event,
+ bounds: Rectangle,
+ cursor: Cursor,
+ ) -> Option<Curve> {
+ let cursor_position = cursor.internal_position(&bounds)?;
+
+ match event {
+ Event::Mouse(mouse_event) => match mouse_event {
+ mouse::Event::Input {
+ button: mouse::Button::Left,
+ state: ButtonState::Pressed,
+ } => match self.state.pending {
+ None => {
+ self.state.pending = Some(Pending::One {
+ from: cursor_position,
+ });
+ None
+ }
+ Some(Pending::One { from }) => {
+ self.state.pending = Some(Pending::Two {
+ from,
+ to: cursor_position,
+ });
+
+ None
+ }
+ Some(Pending::Two { from, to }) => {
+ self.state.pending = None;
+
+ Some(Curve {
+ from,
+ to,
+ control: cursor_position,
+ })
+ }
+ },
+ _ => None,
+ },
+ }
+ }
+
+ fn draw(&self, bounds: Rectangle, cursor: Cursor) -> Vec<Geometry> {
+ let content =
+ self.state.cache.draw(bounds.size(), |frame: &mut Frame| {
+ Curve::draw_all(self.curves, frame);
+
+ frame.stroke(
+ &Path::rectangle(Point::ORIGIN, frame.size()),
+ Stroke::default(),
+ );
+ });
+
+ if let Some(pending) = &self.state.pending {
+ let pending_curve = pending.draw(bounds, cursor);
+
+ vec![content, pending_curve]
+ } else {
+ vec![content]
+ }
+ }
+
+ fn mouse_cursor(
+ &self,
+ bounds: Rectangle,
+ cursor: Cursor,
+ ) -> MouseCursor {
+ if cursor.is_over(&bounds) {
+ MouseCursor::Crosshair
+ } else {
+ MouseCursor::default()
+ }
+ }
+ }
+
+ #[derive(Debug, Clone, Copy)]
+ pub struct Curve {
+ from: Point,
+ to: Point,
+ control: Point,
+ }
+
+ impl Curve {
+ fn draw_all(curves: &[Curve], frame: &mut Frame) {
+ let curves = Path::new(|p| {
+ for curve in curves {
+ p.move_to(curve.from);
+ p.quadratic_curve_to(curve.control, curve.to);
+ }
+ });
+
+ frame.stroke(&curves, Stroke::default().with_width(2.0));
+ }
+ }
+
+ #[derive(Debug, Clone, Copy)]
+ enum Pending {
+ One { from: Point },
+ Two { from: Point, to: Point },
+ }
+
+ impl Pending {
+ fn draw(&self, bounds: Rectangle, cursor: Cursor) -> Geometry {
+ let mut frame = Frame::new(bounds.size());
+
+ if let Some(cursor_position) = cursor.internal_position(&bounds) {
+ match *self {
+ Pending::One { from } => {
+ let line = Path::line(from, cursor_position);
+ frame.stroke(&line, Stroke::default().with_width(2.0));
+ }
+ Pending::Two { from, to } => {
+ let curve = Curve {
+ from,
+ to,
+ control: cursor_position,
+ };
+
+ Curve::draw_all(&[curve], &mut frame);
+ }
+ };
+ }
+
+ frame.into_geometry()
+ }
}
}
diff --git a/examples/clock/Cargo.toml b/examples/clock/Cargo.toml
index 308cbfbb..ab771405 100644
--- a/examples/clock/Cargo.toml
+++ b/examples/clock/Cargo.toml
@@ -5,9 +5,6 @@ authors = ["Héctor Ramón Jiménez <hector0193@gmail.com>"]
edition = "2018"
publish = false
-[features]
-canvas = []
-
[dependencies]
iced = { path = "../..", features = ["canvas", "async-std", "debug"] }
iced_native = { path = "../../native" }
diff --git a/examples/clock/src/main.rs b/examples/clock/src/main.rs
index 827379fa..e6b17d8a 100644
--- a/examples/clock/src/main.rs
+++ b/examples/clock/src/main.rs
@@ -1,6 +1,7 @@
use iced::{
- canvas, executor, Application, Canvas, Color, Command, Container, Element,
- Length, Point, Settings, Subscription, Vector,
+ canvas::{self, Cache, Canvas, Cursor, Geometry, LineCap, Path, Stroke},
+ executor, Application, Color, Command, Container, Element, Length, Point,
+ Rectangle, Settings, Subscription, Vector,
};
pub fn main() {
@@ -11,8 +12,8 @@ pub fn main() {
}
struct Clock {
- now: LocalTime,
- clock: canvas::layer::Cache<LocalTime>,
+ now: chrono::DateTime<chrono::Local>,
+ clock: Cache,
}
#[derive(Debug, Clone, Copy)]
@@ -28,7 +29,7 @@ impl Application for Clock {
fn new(_flags: ()) -> (Self, Command<Message>) {
(
Clock {
- now: chrono::Local::now().into(),
+ now: chrono::Local::now(),
clock: Default::default(),
},
Command::none(),
@@ -59,10 +60,9 @@ impl Application for Clock {
}
fn view(&mut self) -> Element<Message> {
- let canvas = Canvas::new()
+ let canvas = Canvas::new(self)
.width(Length::Units(400))
- .height(Length::Units(400))
- .push(self.clock.with(&self.now));
+ .height(Length::Units(400));
Container::new(canvas)
.width(Length::Fill)
@@ -74,69 +74,54 @@ impl Application for Clock {
}
}
-#[derive(Debug, PartialEq, Eq)]
-struct LocalTime {
- hour: u32,
- minute: u32,
- second: u32,
-}
-
-impl From<chrono::DateTime<chrono::Local>> for LocalTime {
- fn from(date_time: chrono::DateTime<chrono::Local>) -> LocalTime {
+impl canvas::Program<Message> for Clock {
+ fn draw(&self, bounds: Rectangle, _cursor: Cursor) -> Vec<Geometry> {
use chrono::Timelike;
- LocalTime {
- hour: date_time.hour(),
- minute: date_time.minute(),
- second: date_time.second(),
- }
- }
-}
-
-impl canvas::Drawable for LocalTime {
- fn draw(&self, frame: &mut canvas::Frame) {
- use canvas::Path;
+ let clock = self.clock.draw(bounds.size(), |frame| {
+ let center = frame.center();
+ let radius = frame.width().min(frame.height()) / 2.0;
- let center = frame.center();
- let radius = frame.width().min(frame.height()) / 2.0;
+ let background = Path::circle(center, radius);
+ frame.fill(&background, Color::from_rgb8(0x12, 0x93, 0xD8));
- let clock = Path::circle(center, radius);
- frame.fill(&clock, Color::from_rgb8(0x12, 0x93, 0xD8));
+ let short_hand =
+ Path::line(Point::ORIGIN, Point::new(0.0, -0.5 * radius));
- let short_hand =
- Path::line(Point::ORIGIN, Point::new(0.0, -0.5 * radius));
+ let long_hand =
+ Path::line(Point::ORIGIN, Point::new(0.0, -0.8 * radius));
- let long_hand =
- Path::line(Point::ORIGIN, Point::new(0.0, -0.8 * radius));
+ let thin_stroke = Stroke {
+ width: radius / 100.0,
+ color: Color::WHITE,
+ line_cap: LineCap::Round,
+ ..Stroke::default()
+ };
- let thin_stroke = canvas::Stroke {
- width: radius / 100.0,
- color: Color::WHITE,
- line_cap: canvas::LineCap::Round,
- ..canvas::Stroke::default()
- };
+ let wide_stroke = Stroke {
+ width: thin_stroke.width * 3.0,
+ ..thin_stroke
+ };
- let wide_stroke = canvas::Stroke {
- width: thin_stroke.width * 3.0,
- ..thin_stroke
- };
+ frame.translate(Vector::new(center.x, center.y));
- frame.translate(Vector::new(center.x, center.y));
+ frame.with_save(|frame| {
+ frame.rotate(hand_rotation(self.now.hour(), 12));
+ frame.stroke(&short_hand, wide_stroke);
+ });
- frame.with_save(|frame| {
- frame.rotate(hand_rotation(self.hour, 12));
- frame.stroke(&short_hand, wide_stroke);
- });
+ frame.with_save(|frame| {
+ frame.rotate(hand_rotation(self.now.minute(), 60));
+ frame.stroke(&long_hand, wide_stroke);
+ });
- frame.with_save(|frame| {
- frame.rotate(hand_rotation(self.minute, 60));
- frame.stroke(&long_hand, wide_stroke);
+ frame.with_save(|frame| {
+ frame.rotate(hand_rotation(self.now.second(), 60));
+ frame.stroke(&long_hand, thin_stroke);
+ })
});
- frame.with_save(|frame| {
- frame.rotate(hand_rotation(self.second, 60));
- frame.stroke(&long_hand, thin_stroke);
- });
+ vec![clock]
}
}
diff --git a/examples/custom_widget/src/main.rs b/examples/custom_widget/src/main.rs
index 0a570745..d0bceb73 100644
--- a/examples/custom_widget/src/main.rs
+++ b/examples/custom_widget/src/main.rs
@@ -66,7 +66,7 @@ mod circle {
border_width: 0,
border_color: Color::TRANSPARENT,
},
- MouseCursor::OutOfBounds,
+ MouseCursor::default(),
)
}
}
diff --git a/examples/geometry/src/main.rs b/examples/geometry/src/main.rs
index 13a687ab..2a3efd4a 100644
--- a/examples/geometry/src/main.rs
+++ b/examples/geometry/src/main.rs
@@ -12,7 +12,7 @@ mod rainbow {
// implemented by `iced_wgpu` and other renderers.
use iced_native::{
layout, Element, Hasher, Layout, Length, MouseCursor, Point, Size,
- Widget,
+ Vector, Widget,
};
use iced_wgpu::{
triangle::{Mesh2D, Vertex2D},
@@ -85,60 +85,63 @@ mod rainbow {
let posn_l = [0.0, b.height / 2.0];
(
- Primitive::Mesh2D {
- origin: Point::new(b.x, b.y),
- buffers: Mesh2D {
- vertices: vec![
- Vertex2D {
- position: posn_center,
- color: [1.0, 1.0, 1.0, 1.0],
- },
- Vertex2D {
- position: posn_tl,
- color: color_r,
- },
- Vertex2D {
- position: posn_t,
- color: color_o,
- },
- Vertex2D {
- position: posn_tr,
- color: color_y,
- },
- Vertex2D {
- position: posn_r,
- color: color_g,
- },
- Vertex2D {
- position: posn_br,
- color: color_gb,
- },
- Vertex2D {
- position: posn_b,
- color: color_b,
- },
- Vertex2D {
- position: posn_bl,
- color: color_i,
- },
- Vertex2D {
- position: posn_l,
- color: color_v,
- },
- ],
- indices: vec![
- 0, 1, 2, // TL
- 0, 2, 3, // T
- 0, 3, 4, // TR
- 0, 4, 5, // R
- 0, 5, 6, // BR
- 0, 6, 7, // B
- 0, 7, 8, // BL
- 0, 8, 1, // L
- ],
- },
+ Primitive::Translate {
+ translation: Vector::new(b.x, b.y),
+ content: Box::new(Primitive::Mesh2D {
+ size: b.size(),
+ buffers: Mesh2D {
+ vertices: vec![
+ Vertex2D {
+ position: posn_center,
+ color: [1.0, 1.0, 1.0, 1.0],
+ },
+ Vertex2D {
+ position: posn_tl,
+ color: color_r,
+ },
+ Vertex2D {
+ position: posn_t,
+ color: color_o,
+ },
+ Vertex2D {
+ position: posn_tr,
+ color: color_y,
+ },
+ Vertex2D {
+ position: posn_r,
+ color: color_g,
+ },
+ Vertex2D {
+ position: posn_br,
+ color: color_gb,
+ },
+ Vertex2D {
+ position: posn_b,
+ color: color_b,
+ },
+ Vertex2D {
+ position: posn_bl,
+ color: color_i,
+ },
+ Vertex2D {
+ position: posn_l,
+ color: color_v,
+ },
+ ],
+ indices: vec![
+ 0, 1, 2, // TL
+ 0, 2, 3, // T
+ 0, 3, 4, // TR
+ 0, 4, 5, // R
+ 0, 5, 6, // BR
+ 0, 6, 7, // B
+ 0, 7, 8, // BL
+ 0, 8, 1, // L
+ ],
+ },
+ }),
},
- MouseCursor::OutOfBounds,
+ MouseCursor::default(),
)
}
}
diff --git a/examples/integration/src/main.rs b/examples/integration/src/main.rs
index 7203d4b6..da571ed1 100644
--- a/examples/integration/src/main.rs
+++ b/examples/integration/src/main.rs
@@ -63,7 +63,7 @@ pub fn main() {
let mut events = Vec::new();
let mut cache = Some(Cache::default());
let mut renderer = Renderer::new(&mut device, Settings::default());
- let mut output = (Primitive::None, MouseCursor::OutOfBounds);
+ let mut output = (Primitive::None, MouseCursor::default());
let clipboard = Clipboard::new(&window);
// Initialize scene and GUI controls
diff --git a/examples/solar_system/Cargo.toml b/examples/solar_system/Cargo.toml
index c88cda50..0555aa96 100644
--- a/examples/solar_system/Cargo.toml
+++ b/examples/solar_system/Cargo.toml
@@ -5,9 +5,6 @@ authors = ["Héctor Ramón Jiménez <hector0193@gmail.com>"]
edition = "2018"
publish = false
-[features]
-canvas = []
-
[dependencies]
iced = { path = "../..", features = ["canvas", "async-std", "debug"] }
iced_native = { path = "../../native" }
diff --git a/examples/solar_system/src/main.rs b/examples/solar_system/src/main.rs
index bcd1dc71..a25e43df 100644
--- a/examples/solar_system/src/main.rs
+++ b/examples/solar_system/src/main.rs
@@ -7,8 +7,9 @@
//!
//! [1]: https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API/Tutorial/Basic_animations#An_animated_solar_system
use iced::{
- canvas, executor, window, Application, Canvas, Color, Command, Container,
- Element, Length, Point, Settings, Size, Subscription, Vector,
+ canvas::{self, Cursor, Path, Stroke},
+ executor, window, Application, Canvas, Color, Command, Element, Length,
+ Point, Rectangle, Settings, Size, Subscription, Vector,
};
use std::time::Instant;
@@ -22,7 +23,6 @@ pub fn main() {
struct SolarSystem {
state: State,
- solar_system: canvas::layer::Cache<State>,
}
#[derive(Debug, Clone, Copy)]
@@ -39,7 +39,6 @@ impl Application for SolarSystem {
(
SolarSystem {
state: State::new(),
- solar_system: Default::default(),
},
Command::none(),
)
@@ -53,7 +52,6 @@ impl Application for SolarSystem {
match message {
Message::Tick(instant) => {
self.state.update(instant);
- self.solar_system.clear();
}
}
@@ -66,24 +64,20 @@ impl Application for SolarSystem {
}
fn view(&mut self) -> Element<Message> {
- let canvas = Canvas::new()
+ Canvas::new(&mut self.state)
.width(Length::Fill)
.height(Length::Fill)
- .push(self.solar_system.with(&self.state));
-
- Container::new(canvas)
- .width(Length::Fill)
- .height(Length::Fill)
- .center_x()
- .center_y()
.into()
}
}
#[derive(Debug)]
struct State {
+ space_cache: canvas::Cache,
+ system_cache: canvas::Cache,
+ cursor_position: Point,
start: Instant,
- current: Instant,
+ now: Instant,
stars: Vec<(Point, f32)>,
}
@@ -99,102 +93,123 @@ impl State {
let (width, height) = window::Settings::default().size;
State {
+ space_cache: Default::default(),
+ system_cache: Default::default(),
+ cursor_position: Point::ORIGIN,
start: now,
- current: now,
- stars: {
- use rand::Rng;
-
- let mut rng = rand::thread_rng();
-
- (0..100)
- .map(|_| {
- (
- Point::new(
- rng.gen_range(0.0, width as f32),
- rng.gen_range(0.0, height as f32),
- ),
- rng.gen_range(0.5, 1.0),
- )
- })
- .collect()
- },
+ now,
+ stars: Self::generate_stars(width, height),
}
}
pub fn update(&mut self, now: Instant) {
- self.current = now;
+ self.now = now;
+ self.system_cache.clear();
+ }
+
+ fn generate_stars(width: u32, height: u32) -> Vec<(Point, f32)> {
+ use rand::Rng;
+
+ let mut rng = rand::thread_rng();
+
+ (0..100)
+ .map(|_| {
+ (
+ Point::new(
+ rng.gen_range(
+ -(width as f32) / 2.0,
+ width as f32 / 2.0,
+ ),
+ rng.gen_range(
+ -(height as f32) / 2.0,
+ height as f32 / 2.0,
+ ),
+ ),
+ rng.gen_range(0.5, 1.0),
+ )
+ })
+ .collect()
}
}
-impl canvas::Drawable for State {
- fn draw(&self, frame: &mut canvas::Frame) {
- use canvas::{Path, Stroke};
+impl<Message> canvas::Program<Message> for State {
+ fn draw(
+ &self,
+ bounds: Rectangle,
+ _cursor: Cursor,
+ ) -> Vec<canvas::Geometry> {
use std::f32::consts::PI;
- let center = frame.center();
+ let background = self.space_cache.draw(bounds.size(), |frame| {
+ let space = Path::rectangle(Point::new(0.0, 0.0), frame.size());
- let space = Path::rectangle(Point::new(0.0, 0.0), frame.size());
+ let stars = Path::new(|path| {
+ for (p, size) in &self.stars {
+ path.rectangle(*p, Size::new(*size, *size));
+ }
+ });
- let stars = Path::new(|path| {
- for (p, size) in &self.stars {
- path.rectangle(*p, Size::new(*size, *size));
- }
+ frame.fill(&space, Color::BLACK);
+
+ frame.translate(frame.center() - Point::ORIGIN);
+ frame.fill(&stars, Color::WHITE);
});
- let sun = Path::circle(center, Self::SUN_RADIUS);
- let orbit = Path::circle(center, Self::ORBIT_RADIUS);
-
- frame.fill(&space, Color::BLACK);
- frame.fill(&stars, Color::WHITE);
- frame.fill(&sun, Color::from_rgb8(0xF9, 0xD7, 0x1C));
- frame.stroke(
- &orbit,
- Stroke {
- width: 1.0,
- color: Color::from_rgba8(0, 153, 255, 0.1),
- ..Stroke::default()
- },
- );
+ let system = self.system_cache.draw(bounds.size(), |frame| {
+ let center = frame.center();
- let elapsed = self.current - self.start;
- let elapsed_seconds = elapsed.as_secs() as f32;
- let elapsed_millis = elapsed.subsec_millis() as f32;
+ let sun = Path::circle(center, Self::SUN_RADIUS);
+ let orbit = Path::circle(center, Self::ORBIT_RADIUS);
- frame.with_save(|frame| {
- frame.translate(Vector::new(center.x, center.y));
- frame.rotate(
- (2.0 * PI / 60.0) * elapsed_seconds
- + (2.0 * PI / 60_000.0) * elapsed_millis,
- );
- frame.translate(Vector::new(Self::ORBIT_RADIUS, 0.0));
-
- let earth = Path::circle(Point::ORIGIN, Self::EARTH_RADIUS);
- let shadow = Path::rectangle(
- Point::new(0.0, -Self::EARTH_RADIUS),
- Size::new(Self::EARTH_RADIUS * 4.0, Self::EARTH_RADIUS * 2.0),
+ frame.fill(&sun, Color::from_rgb8(0xF9, 0xD7, 0x1C));
+ frame.stroke(
+ &orbit,
+ Stroke {
+ width: 1.0,
+ color: Color::from_rgba8(0, 153, 255, 0.1),
+ ..Stroke::default()
+ },
);
- frame.fill(&earth, Color::from_rgb8(0x6B, 0x93, 0xD6));
+ let elapsed = self.now - self.start;
+ let rotation = (2.0 * PI / 60.0) * elapsed.as_secs() as f32
+ + (2.0 * PI / 60_000.0) * elapsed.subsec_millis() as f32;
frame.with_save(|frame| {
- frame.rotate(
- ((2.0 * PI) / 6.0) * elapsed_seconds
- + ((2.0 * PI) / 6_000.0) * elapsed_millis,
+ frame.translate(Vector::new(center.x, center.y));
+ frame.rotate(rotation);
+ frame.translate(Vector::new(Self::ORBIT_RADIUS, 0.0));
+
+ let earth = Path::circle(Point::ORIGIN, Self::EARTH_RADIUS);
+ let shadow = Path::rectangle(
+ Point::new(0.0, -Self::EARTH_RADIUS),
+ Size::new(
+ Self::EARTH_RADIUS * 4.0,
+ Self::EARTH_RADIUS * 2.0,
+ ),
);
- frame.translate(Vector::new(0.0, Self::MOON_DISTANCE));
- let moon = Path::circle(Point::ORIGIN, Self::MOON_RADIUS);
- frame.fill(&moon, Color::WHITE);
- });
+ frame.fill(&earth, Color::from_rgb8(0x6B, 0x93, 0xD6));
- frame.fill(
- &shadow,
- Color {
- a: 0.7,
- ..Color::BLACK
- },
- );
+ frame.with_save(|frame| {
+ frame.rotate(rotation * 10.0);
+ frame.translate(Vector::new(0.0, Self::MOON_DISTANCE));
+
+ let moon = Path::circle(Point::ORIGIN, Self::MOON_RADIUS);
+ frame.fill(&moon, Color::WHITE);
+ });
+
+ frame.fill(
+ &shadow,
+ Color {
+ a: 0.7,
+ ..Color::BLACK
+ },
+ );
+ });
});
+
+ vec![background, system]
}
}
generated by cgit (git 2.34.1) at 2025-05-17 23:35:54 +0000