Merge pull request #325 from hecrj/feature/canvas-interaction

Canvas interactivity and Game of Life example

1 files changed, 99 insertions, 120 deletions

diff --git a/examples/solar_system/src/main.rs b/examples/solar_system/src/main.rs
index bcd1dc71..98bd3b21 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, time, 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,137 +93,122 @@ 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);
 
-        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()
-            },
-        );
+            frame.translate(frame.center() - Point::ORIGIN);
+            frame.fill(&stars, Color::WHITE);
+        });
 
-        let elapsed = self.current - self.start;
-        let elapsed_seconds = elapsed.as_secs() as f32;
-        let elapsed_millis = elapsed.subsec_millis() as f32;
+        let system = self.system_cache.draw(bounds.size(), |frame| {
+            let center = frame.center();
 
-        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 sun = Path::circle(center, Self::SUN_RADIUS);
+            let orbit = Path::circle(center, Self::ORBIT_RADIUS);
 
-            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(
-                &shadow,
-                Color {
-                    a: 0.7,
-                    ..Color::BLACK
-                },
-            );
-        });
-    }
-}
-
-mod time {
-    use iced::futures;
-    use std::time::Instant;
-
-    pub fn every(duration: std::time::Duration) -> iced::Subscription<Instant> {
-        iced::Subscription::from_recipe(Every(duration))
-    }
+                frame.fill(&earth, Color::from_rgb8(0x6B, 0x93, 0xD6));
 
-    struct Every(std::time::Duration);
+                frame.with_save(|frame| {
+                    frame.rotate(rotation * 10.0);
+                    frame.translate(Vector::new(0.0, Self::MOON_DISTANCE));
 
-    impl<H, I> iced_native::subscription::Recipe<H, I> for Every
-    where
-        H: std::hash::Hasher,
-    {
-        type Output = Instant;
+                    let moon = Path::circle(Point::ORIGIN, Self::MOON_RADIUS);
+                    frame.fill(&moon, Color::WHITE);
+                });
 
-        fn hash(&self, state: &mut H) {
-            use std::hash::Hash;
-
-            std::any::TypeId::of::<Self>().hash(state);
-            self.0.hash(state);
-        }
-
-        fn stream(
-            self: Box<Self>,
-            _input: futures::stream::BoxStream<'static, I>,
-        ) -> futures::stream::BoxStream<'static, Self::Output> {
-            use futures::stream::StreamExt;
+                frame.fill(
+                    &shadow,
+                    Color {
+                        a: 0.7,
+                        ..Color::BLACK
+                    },
+                );
+            });
+        });
 
-            async_std::stream::interval(self.0)
-                .map(|_| Instant::now())
-                .boxed()
-        }
+        vec![background, system]
     }
 }