Basic wgpu renderer

.github/workflows/integration.yml

@@ -24,6 +24,3 @@ jobs:
     - uses: actions/checkout@master
     - name: Run tests
       run: cargo test --verbose --all --all-features
-    - name: Build tour for WebAssembly
-      if: matrix.targets == 'wasm32-unknown-unknown'
-      run: cargo build --verbose --package iced_tour --lib --target wasm32-unknown-unknown

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "iced"
-version = "0.1.0-alpha"
+version = "0.1.0-alpha.1"
 authors = ["Héctor Ramón Jiménez <hector0193@gmail.com>"]
 edition = "2018"
 description = "A cross-platform GUI library inspired by Elm"
@@ -19,5 +19,19 @@ members = [
     "core",
     "native",
     "web",
-    "examples/tour",
+    "wgpu",
+    "winit",
 ]
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+iced_winit = { version = "0.1.0-alpha", path = "winit" }
+iced_wgpu = { version = "0.1.0-alpha", path = "wgpu" }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+iced_web = { version = "0.1.0-alpha", path = "web" }
+
+[dev-dependencies]
+env_logger = "0.7"
+
+[target.'cfg(target_arch = "wasm32")'.dev-dependencies]
+wasm-bindgen = "0.2.51"

README.md

@@ -87,10 +87,9 @@ __view logic__:
 
 ```rust
 use iced::{Button, Column, Text};
-use iced_wgpu::Renderer; // Iced does not include a renderer! We need to bring our own!
 
 impl Counter {
-    pub fn view(&mut self) -> Column<Message, Renderer> {
+    pub fn view(&mut self) -> Column<Message> {
         // We use a column: a simple vertical layout
         Column::new()
             .push(

core/src/background.rs

@@ -0,0 +1,7 @@
+use crate::Color;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Background {
+    Color(Color),
+    // TODO: Add gradient and image variants
+}

core/src/color.rs

@@ -16,4 +16,31 @@ impl Color {
         b: 0.0,
         a: 1.0,
     };
+
+    /// The white color.
+    pub const WHITE: Color = Color {
+        r: 1.0,
+        g: 1.0,
+        b: 1.0,
+        a: 1.0,
+    };
+
+    pub fn into_linear(self) -> [f32; 4] {
+        // As described in:
+        // https://en.wikipedia.org/wiki/SRGB#The_reverse_transformation
+        fn linear_component(u: f32) -> f32 {
+            if u < 0.04045 {
+                u / 12.92
+            } else {
+                ((u + 0.055) / 1.055).powf(2.4)
+            }
+        }
+
+        [
+            linear_component(self.r),
+            linear_component(self.g),
+            linear_component(self.b),
+            self.a,
+        ]
+    }
 }

core/src/lib.rs

@@ -1,6 +1,7 @@
 pub mod widget;
 
 mod align;
+mod background;
 mod color;
 mod justify;
 mod length;
@@ -9,6 +10,7 @@ mod rectangle;
 mod vector;
 
 pub use align::Align;
+pub use background::Background;
 pub use color::Color;
 pub use justify::Justify;
 pub use length::Length;

core/src/widget/button.rs

@@ -5,68 +5,58 @@
 //! [`Button`]: struct.Button.html
 //! [`State`]: struct.State.html
 
-use crate::{Align, Length};
+use crate::{Align, Background, Length};
 
 /// A generic widget that produces a message when clicked.
-///
-/// # Example
-///
-/// ```
-/// use iced_core::{button, Button};
-///
-/// pub enum Message {
-///     ButtonClicked,
-/// }
-///
-/// let state = &mut button::State::new();
-///
-/// Button::new(state, "Click me!")
-///     .on_press(Message::ButtonClicked);
-/// ```
-///
-/// ![Button drawn by Coffee's renderer](https://github.com/hecrj/coffee/blob/bda9818f823dfcb8a7ad0ff4940b4d4b387b5208/images/ui/button.png?raw=true)
-pub struct Button<'a, Message> {
+pub struct Button<'a, Message, Element> {
     /// The current state of the button
     pub state: &'a mut State,
 
-    /// The label of the button
-    pub label: String,
+    pub content: Element,
 
     /// The message to produce when the button is pressed
     pub on_press: Option<Message>,
 
-    pub class: Class,
-
     pub width: Length,
 
+    pub padding: u16,
+
+    pub background: Option<Background>,
+
+    pub border_radius: u16,
+
     pub align_self: Option<Align>,
 }
 
-impl<'a, Message> std::fmt::Debug for Button<'a, Message>
+impl<'a, Message, Element> std::fmt::Debug for Button<'a, Message, Element>
 where
     Message: std::fmt::Debug,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("Button")
             .field("state", &self.state)
-            .field("label", &self.label)
             .field("on_press", &self.on_press)
             .finish()
     }
 }
 
-impl<'a, Message> Button<'a, Message> {
+impl<'a, Message, Element> Button<'a, Message, Element> {
     /// Creates a new [`Button`] with some local [`State`] and the given label.
     ///
     /// [`Button`]: struct.Button.html
     /// [`State`]: struct.State.html
-    pub fn new(state: &'a mut State, label: &str) -> Self {
+    pub fn new<E>(state: &'a mut State, content: E) -> Self
+    where
+        E: Into<Element>,
+    {
         Button {
             state,
-            label: String::from(label),
+            content: content.into(),
             on_press: None,
-            class: Class::Primary,
             width: Length::Shrink,
+            padding: 0,
+            background: None,
+            border_radius: 0,
             align_self: None,
         }
     }
@@ -79,6 +69,21 @@ impl<'a, Message> Button<'a, Message> {
         self
     }
 
+    pub fn padding(mut self, padding: u16) -> Self {
+        self.padding = padding;
+        self
+    }
+
+    pub fn background(mut self, background: Background) -> Self {
+        self.background = Some(background);
+        self
+    }
+
+    pub fn border_radius(mut self, border_radius: u16) -> Self {
+        self.border_radius = border_radius;
+        self
+    }
+
     /// Sets the alignment of the [`Button`] itself.
     ///
     /// This is useful if you want to override the default alignment given by
@@ -90,16 +95,6 @@ impl<'a, Message> Button<'a, Message> {
         self
     }
 
-    /// Sets the [`Class`] of the [`Button`].
-    ///
-    ///
-    /// [`Button`]: struct.Button.html
-    /// [`Class`]: enum.Class.html
-    pub fn class(mut self, class: Class) -> Self {
-        self.class = class;
-        self
-    }
-
     /// Sets the message that will be produced when the [`Button`] is pressed.
     ///
     /// [`Button`]: struct.Button.html
@@ -133,26 +128,3 @@ impl State {
         self.is_pressed
     }
 }
-
-/// The type of a [`Button`].
-///
-/// ![Different buttons drawn by the built-in renderer in Coffee](https://github.com/hecrj/coffee/blob/bda9818f823dfcb8a7ad0ff4940b4d4b387b5208/images/ui/button_classes.png?raw=true)
-///
-/// [`Button`]: struct.Button.html
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Class {
-    /// The [`Button`] performs the main action.
-    ///
-    /// [`Button`]: struct.Button.html
-    Primary,
-
-    /// The [`Button`] performs an alternative action.
-    ///
-    /// [`Button`]: struct.Button.html
-    Secondary,
-
-    /// The [`Button`] performs a productive action.
-    ///
-    /// [`Button`]: struct.Button.html
-    Positive,
-}

core/src/widget/image.rs

@@ -9,12 +9,12 @@ use crate::{Align, Length, Rectangle};
 /// ```
 /// use iced_core::Image;
 ///
-/// # let my_handle = String::from("some_handle");
-/// let image = Image::new(my_handle);
+/// let image = Image::new("resources/ferris.png");
 /// ```
-pub struct Image<I> {
-    /// The image handle
-    pub handle: I,
+#[derive(Debug)]
+pub struct Image {
+    /// The image path
+    pub path: String,
 
     /// The part of the image to show
     pub clip: Option<Rectangle<u16>>,
@@ -28,23 +28,13 @@ pub struct Image<I> {
     pub align_self: Option<Align>,
 }
 
-impl<I> std::fmt::Debug for Image<I> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("Image")
-            .field("clip", &self.clip)
-            .field("width", &self.width)
-            .field("height", &self.height)
-            .finish()
-    }
-}
-
-impl<I> Image<I> {
-    /// Creates a new [`Image`] with given image handle.
+impl Image {
+    /// Creates a new [`Image`] with the given path.
     ///
     /// [`Image`]: struct.Image.html
-    pub fn new(handle: I) -> Self {
+    pub fn new<T: Into<String>>(path: T) -> Self {
         Image {
-            handle,
+            path: path.into(),
             clip: None,
             width: Length::Shrink,
             height: Length::Shrink,