Merge branch 'master' into improvement/update-wgpu_glyph

8 files changed, 133 insertions, 156 deletions

diff --git a/examples/custom_widget/Cargo.toml b/examples/custom_widget/Cargo.toml
index 30747dc0..3942538d 100644
--- a/examples/custom_widget/Cargo.toml
+++ b/examples/custom_widget/Cargo.toml
@@ -8,4 +8,4 @@ publish = false
 [dependencies]
 iced = { path = "../.." }
 iced_native = { path = "../../native" }
-iced_wgpu = { path = "../../wgpu" }
+iced_graphics = { path = "../../graphics" }
diff --git a/examples/custom_widget/src/main.rs b/examples/custom_widget/src/main.rs
index f096fb54..bcf896b0 100644
--- a/examples/custom_widget/src/main.rs
+++ b/examples/custom_widget/src/main.rs
@@ -9,11 +9,11 @@ mod circle {
     // 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_graphics::{Backend, Defaults, Primitive, Renderer};
     use iced_native::{
         layout, mouse, Background, Color, Element, Hasher, Layout, Length,
         Point, Size, Widget,
     };
-    use iced_wgpu::{Defaults, Primitive, Renderer};
 
     pub struct Circle {
         radius: u16,
@@ -25,7 +25,10 @@ mod circle {
         }
     }
 
-    impl<Message> Widget<Message, Renderer> for Circle {
+    impl<Message, B> Widget<Message, Renderer<B>> for Circle
+    where
+        B: Backend,
+    {
         fn width(&self) -> Length {
             Length::Shrink
         }
@@ -36,7 +39,7 @@ mod circle {
 
         fn layout(
             &self,
-            _renderer: &Renderer,
+            _renderer: &Renderer<B>,
             _limits: &layout::Limits,
         ) -> layout::Node {
             layout::Node::new(Size::new(
@@ -53,7 +56,7 @@ mod circle {
 
         fn draw(
             &self,
-            _renderer: &mut Renderer,
+            _renderer: &mut Renderer<B>,
             _defaults: &Defaults,
             layout: Layout<'_>,
             _cursor_position: Point,
@@ -71,8 +74,11 @@ mod circle {
         }
     }
 
-    impl<'a, Message> Into<Element<'a, Message, Renderer>> for Circle {
-        fn into(self) -> Element<'a, Message, Renderer> {
+    impl<'a, Message, B> Into<Element<'a, Message, Renderer<B>>> for Circle
+    where
+        B: Backend,
+    {
+        fn into(self) -> Element<'a, Message, Renderer<B>> {
             Element::new(self)
         }
     }
diff --git a/examples/geometry/Cargo.toml b/examples/geometry/Cargo.toml
index 9df52454..34eec4fb 100644
--- a/examples/geometry/Cargo.toml
+++ b/examples/geometry/Cargo.toml
@@ -8,4 +8,4 @@ publish = false
 [dependencies]
 iced = { path = "../.." }
 iced_native = { path = "../../native" }
-iced_wgpu = { path = "../../wgpu" }
+iced_graphics = { path = "../../graphics" }
diff --git a/examples/geometry/src/main.rs b/examples/geometry/src/main.rs
index aabe6b21..71ce0d8c 100644
--- a/examples/geometry/src/main.rs
+++ b/examples/geometry/src/main.rs
@@ -10,14 +10,14 @@ mod rainbow {
     // 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_graphics::{
+        triangle::{Mesh2D, Vertex2D},
+        Backend, Defaults, Primitive, Renderer,
+    };
     use iced_native::{
         layout, mouse, Element, Hasher, Layout, Length, Point, Size, Vector,
         Widget,
     };
-    use iced_wgpu::{
-        triangle::{Mesh2D, Vertex2D},
-        Defaults, Primitive, Renderer,
-    };
 
     pub struct Rainbow;
 
@@ -27,7 +27,10 @@ mod rainbow {
         }
     }
 
-    impl<Message> Widget<Message, Renderer> for Rainbow {
+    impl<Message, B> Widget<Message, Renderer<B>> for Rainbow
+    where
+        B: Backend,
+    {
         fn width(&self) -> Length {
             Length::Fill
         }
@@ -38,7 +41,7 @@ mod rainbow {
 
         fn layout(
             &self,
-            _renderer: &Renderer,
+            _renderer: &Renderer<B>,
             limits: &layout::Limits,
         ) -> layout::Node {
             let size = limits.width(Length::Fill).resolve(Size::ZERO);
@@ -50,7 +53,7 @@ mod rainbow {
 
         fn draw(
             &self,
-            _renderer: &mut Renderer,
+            _renderer: &mut Renderer<B>,
             _defaults: &Defaults,
             layout: Layout<'_>,
             cursor_position: Point,
@@ -146,8 +149,11 @@ mod rainbow {
         }
     }
 
-    impl<'a, Message> Into<Element<'a, Message, Renderer>> for Rainbow {
-        fn into(self) -> Element<'a, Message, Renderer> {
+    impl<'a, Message, B> Into<Element<'a, Message, Renderer<B>>> for Rainbow
+    where
+        B: Backend,
+    {
+        fn into(self) -> Element<'a, Message, Renderer<B>> {
             Element::new(self)
         }
     }
diff --git a/examples/integration/src/controls.rs b/examples/integration/src/controls.rs
index 0999336b..81c35072 100644
--- a/examples/integration/src/controls.rs
+++ b/examples/integration/src/controls.rs
@@ -1,11 +1,11 @@
-use crate::Scene;
-
 use iced_wgpu::Renderer;
 use iced_winit::{
-    slider, Align, Color, Column, Element, Length, Row, Slider, Text,
+    slider, Align, Color, Column, Command, Element, Length, Program, Row,
+    Slider, Text,
 };
 
 pub struct Controls {
+    background_color: Color,
     sliders: [slider::State; 3],
 }
 
@@ -17,58 +17,55 @@ pub enum Message {
 impl Controls {
     pub fn new() -> Controls {
         Controls {
+            background_color: Color::BLACK,
             sliders: Default::default(),
         }
     }
 
-    pub fn update(&self, message: Message, scene: &mut Scene) {
+    pub fn background_color(&self) -> Color {
+        self.background_color
+    }
+}
+
+impl Program for Controls {
+    type Renderer = Renderer;
+    type Message = Message;
+
+    fn update(&mut self, message: Message) -> Command<Message> {
         match message {
             Message::BackgroundColorChanged(color) => {
-                scene.background_color = color;
+                self.background_color = color;
             }
         }
+
+        Command::none()
     }
 
-    pub fn view(&mut self, scene: &Scene) -> Element<Message, Renderer> {
+    fn view(&mut self) -> Element<Message, Renderer> {
         let [r, g, b] = &mut self.sliders;
-        let background_color = scene.background_color;
+        let background_color = self.background_color;
 
         let sliders = Row::new()
             .width(Length::Units(500))
             .spacing(20)
-            .push(Slider::new(
-                r,
-                0.0..=1.0,
-                scene.background_color.r,
-                move |r| {
-                    Message::BackgroundColorChanged(Color {
-                        r,
-                        ..background_color
-                    })
-                },
-            ))
-            .push(Slider::new(
-                g,
-                0.0..=1.0,
-                scene.background_color.g,
-                move |g| {
-                    Message::BackgroundColorChanged(Color {
-                        g,
-                        ..background_color
-                    })
-                },
-            ))
-            .push(Slider::new(
-                b,
-                0.0..=1.0,
-                scene.background_color.b,
-                move |b| {
-                    Message::BackgroundColorChanged(Color {
-                        b,
-                        ..background_color
-                    })
-                },
-            ));
+            .push(Slider::new(r, 0.0..=1.0, background_color.r, move |r| {
+                Message::BackgroundColorChanged(Color {
+                    r,
+                    ..background_color
+                })
+            }))
+            .push(Slider::new(g, 0.0..=1.0, background_color.g, move |g| {
+                Message::BackgroundColorChanged(Color {
+                    g,
+                    ..background_color
+                })
+            }))
+            .push(Slider::new(b, 0.0..=1.0, background_color.b, move |b| {
+                Message::BackgroundColorChanged(Color {
+                    b,
+                    ..background_color
+                })
+            }));
 
         Row::new()
             .width(Length::Fill)
diff --git a/examples/integration/src/main.rs b/examples/integration/src/main.rs
index 92d2fa8d..c1fe8f69 100644
--- a/examples/integration/src/main.rs
+++ b/examples/integration/src/main.rs
@@ -4,12 +4,8 @@ mod scene;
 use controls::Controls;
 use scene::Scene;
 
-use iced_wgpu::{
-    wgpu, window::SwapChain, Primitive, Renderer, Settings, Target,
-};
-use iced_winit::{
-    futures, mouse, winit, Cache, Clipboard, Size, UserInterface,
-};
+use iced_wgpu::{wgpu, Backend, Renderer, Settings, Viewport};
+use iced_winit::{futures, program, winit, Debug, Size};
 
 use winit::{
     event::{Event, ModifiersState, WindowEvent},
@@ -22,12 +18,15 @@ pub fn main() {
     // Initialize winit
     let event_loop = EventLoop::new();
     let window = winit::window::Window::new(&event_loop).unwrap();
-    let mut logical_size =
-        window.inner_size().to_logical(window.scale_factor());
-    let mut modifiers = ModifiersState::default();
 
-    // Initialize WGPU
+    let physical_size = window.inner_size();
+    let mut viewport = Viewport::with_physical_size(
+        Size::new(physical_size.width, physical_size.height),
+        window.scale_factor(),
+    );
+    let mut modifiers = ModifiersState::default();
 
+    // Initialize wgpu
     let surface = wgpu::Surface::create(&window);
     let (mut device, queue) = futures::executor::block_on(async {
         let adapter = wgpu::Adapter::request(
@@ -55,20 +54,34 @@ pub fn main() {
     let mut swap_chain = {
         let size = window.inner_size();
 
-        SwapChain::new(&device, &surface, format, size.width, size.height)
+        device.create_swap_chain(
+            &surface,
+            &wgpu::SwapChainDescriptor {
+                usage: wgpu::TextureUsage::OUTPUT_ATTACHMENT,
+                format: format,
+                width: size.width,
+                height: size.height,
+                present_mode: wgpu::PresentMode::Mailbox,
+            },
+        )
     };
     let mut resized = false;
 
+    // Initialize scene and GUI controls
+    let scene = Scene::new(&mut device);
+    let controls = Controls::new();
+
     // Initialize iced
-    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, mouse::Interaction::default());
-    let clipboard = Clipboard::new(&window);
+    let mut debug = Debug::new();
+    let mut renderer =
+        Renderer::new(Backend::new(&mut device, Settings::default()));
 
-    // Initialize scene and GUI controls
-    let mut scene = Scene::new(&device);
-    let mut controls = Controls::new();
+    let mut state = program::State::new(
+        controls,
+        viewport.logical_size(),
+        &mut renderer,
+        &mut debug,
+    );
 
     // Run event loop
     event_loop.run(move |event, _, control_flow| {
@@ -82,8 +95,11 @@ pub fn main() {
                         modifiers = new_modifiers;
                     }
                     WindowEvent::Resized(new_size) => {
-                        logical_size =
-                            new_size.to_logical(window.scale_factor());
+                        viewport = Viewport::with_physical_size(
+                            Size::new(new_size.width, new_size.height),
+                            window.scale_factor(),
+                        );
+
                         resized = true;
                     }
                     WindowEvent::CloseRequested => {
@@ -99,69 +115,18 @@ pub fn main() {
                     window.scale_factor(),
                     modifiers,
                 ) {
-                    events.push(event);
+                    state.queue_event(event);
                 }
             }
             Event::MainEventsCleared => {
-                // If no relevant events happened, we can simply skip this
-                if events.is_empty() {
-                    return;
-                }
-
-                // We need to:
-                // 1. Process events of our user interface.
-                // 2. Update state as a result of any interaction.
-                // 3. Generate a new output for our renderer.
-
-                // First, we build our user interface.
-                let mut user_interface = UserInterface::build(
-                    controls.view(&scene),
-                    Size::new(logical_size.width, logical_size.height),
-                    cache.take().unwrap(),
+                // We update iced
+                let _ = state.update(
+                    None,
+                    viewport.logical_size(),
                     &mut renderer,
+                    &mut debug,
                 );
 
-                // Then, we process the events, obtaining messages in return.
-                let messages = user_interface.update(
-                    events.drain(..),
-                    clipboard.as_ref().map(|c| c as _),
-                    &renderer,
-                );
-
-                let user_interface = if messages.is_empty() {
-                    // If there are no messages, no interactions we care about have
-                    // happened. We can simply leave our user interface as it is.
-                    user_interface
-                } else {
-                    // If there are messages, we need to update our state
-                    // accordingly and rebuild our user interface.
-                    // We can only do this if we drop our user interface first
-                    // by turning it into its cache.
-                    cache = Some(user_interface.into_cache());
-
-                    // In this example, `Controls` is the only part that cares
-                    // about messages, so updating our state is pretty
-                    // straightforward.
-                    for message in messages {
-                        controls.update(message, &mut scene);
-                    }
-
-                    // Once the state has been changed, we rebuild our updated
-                    // user interface.
-                    UserInterface::build(
-                        controls.view(&scene),
-                        Size::new(logical_size.width, logical_size.height),
-                        cache.take().unwrap(),
-                        &mut renderer,
-                    )
-                };
-
-                // Finally, we just need to draw a new output for our renderer,
-                output = user_interface.draw(&mut renderer);
-
-                // update our cache,
-                cache = Some(user_interface.into_cache());
-
                 // and request a redraw
                 window.request_redraw();
             }
@@ -169,36 +134,41 @@ pub fn main() {
                 if resized {
                     let size = window.inner_size();
 
-                    swap_chain = SwapChain::new(
-                        &device,
+                    swap_chain = device.create_swap_chain(
                         &surface,
-                        format,
-                        size.width,
-                        size.height,
+                        &wgpu::SwapChainDescriptor {
+                            usage: wgpu::TextureUsage::OUTPUT_ATTACHMENT,
+                            format: format,
+                            width: size.width,
+                            height: size.height,
+                            present_mode: wgpu::PresentMode::Mailbox,
+                        },
                     );
                 }
 
-                let (frame, viewport) =
-                    swap_chain.next_frame().expect("Next frame");
+                let frame = swap_chain.get_next_texture().expect("Next frame");
 
                 let mut encoder = device.create_command_encoder(
                     &wgpu::CommandEncoderDescriptor { label: None },
                 );
 
                 // We draw the scene first
-                scene.draw(&mut encoder, &frame.view);
+                let program = state.program();
+
+                scene.draw(
+                    &mut encoder,
+                    &frame.view,
+                    program.background_color(),
+                );
 
                 // And then iced on top
-                let mouse_interaction = renderer.draw(
+                let mouse_interaction = renderer.backend_mut().draw(
                     &mut device,
                     &mut encoder,
-                    Target {
-                        texture: &frame.view,
-                        viewport,
-                    },
-                    &output,
-                    window.scale_factor(),
-                    &["Some debug information!"],
+                    &frame.view,
+                    &viewport,
+                    state.primitive(),
+                    &debug.overlay(),
                 );
 
                 // Then we submit the work
diff --git a/examples/integration/src/scene.rs b/examples/integration/src/scene.rs
index 22c6812a..b79a7ff4 100644
--- a/examples/integration/src/scene.rs
+++ b/examples/integration/src/scene.rs
@@ -2,7 +2,6 @@ use iced_wgpu::wgpu;
 use iced_winit::Color;
 
 pub struct Scene {
-    pub background_color: Color,
     pipeline: wgpu::RenderPipeline,
     bind_group: wgpu::BindGroup,
 }
@@ -12,7 +11,6 @@ impl Scene {
         let (pipeline, bind_group) = build_pipeline(device);
 
         Scene {
-            background_color: Color::BLACK,
             pipeline,
             bind_group,
         }
@@ -22,6 +20,7 @@ impl Scene {
         &self,
         encoder: &mut wgpu::CommandEncoder,
         target: &wgpu::TextureView,
+        background_color: Color,
     ) {
         let mut rpass =
             encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
@@ -32,8 +31,7 @@ impl Scene {
                         load_op: wgpu::LoadOp::Clear,
                         store_op: wgpu::StoreOp::Store,
                         clear_color: {
-                            let [r, g, b, a] =
-                                self.background_color.into_linear();
+                            let [r, g, b, a] = background_color.into_linear();
 
                             wgpu::Color {
                                 r: r as f64,
diff --git a/examples/todos/Cargo.toml b/examples/todos/Cargo.toml
index f945cde5..b236cc0d 100644
--- a/examples/todos/Cargo.toml
+++ b/examples/todos/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2018"
 publish = false
 
 [dependencies]
-iced = { path = "../..", features = ["async-std"] }
+iced = { path = "../..", features = ["async-std", "debug"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"