Implement Geometry2D primitive

core/src/geometry.rs

@@ -0,0 +1,20 @@
+/// A two-dimensional vertex which has a color
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub struct Vertex2D {
+    /// The vertex position
+    pub position: [f32; 2],
+    /// The vertex color in rgba
+    pub color: [f32; 4],
+}
+
+/// A set of [`Vertex2D`] and indices for drawing some 2D geometry on the GPU.
+///
+/// [`Vertex2D`]: struct.Vertex2D.html
+#[derive(Clone, Debug)]
+pub struct Geometry2D {
+    /// The vertices for this geometry
+    pub vertices: Vec<Vertex2D>,
+    /// The indices for this geometry
+    pub indices: Vec<u16>,
+}

core/src/lib.rs

@@ -23,6 +23,7 @@ mod length;
 mod point;
 mod rectangle;
 mod vector;
+mod geometry;
 
 pub use align::{Align, HorizontalAlignment, VerticalAlignment};
 pub use background::Background;
@@ -32,6 +33,7 @@ pub use length::Length;
 pub use point::Point;
 pub use rectangle::Rectangle;
 pub use vector::Vector;
+pub use geometry::{Vertex2D, Geometry2D};
 
 #[cfg(feature = "command")]
 mod command;

examples/geometry.rs

@@ -0,0 +1,227 @@
+//! This example showcases a simple native custom widget that renders using
+//! arbitrary low-level geometry.
+mod rainbow {
+    // 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::{
+        layout,  Element, Geometry2D, Hasher, Layout, Length,
+        MouseCursor, Point, Size, Vertex2D, Widget,
+    };
+    use iced_wgpu::{Primitive, Renderer};
+
+    pub struct Rainbow {
+        dimen: u16,
+    }
+
+    impl Rainbow {
+        pub fn new(dimen: u16) -> Self {
+            Self { dimen }
+        }
+    }
+
+    impl<Message> Widget<Message, Renderer> for Rainbow {
+        fn width(&self) -> Length {
+            Length::Shrink
+        }
+
+        fn height(&self) -> Length {
+            Length::Shrink
+        }
+
+        fn layout(
+            &self,
+            _renderer: &Renderer,
+            _limits: &layout::Limits,
+        ) -> layout::Node {
+            layout::Node::new(Size::new(
+                f32::from(self.dimen),
+                f32::from(self.dimen),
+            ))
+        }
+
+        fn hash_layout(&self, state: &mut Hasher) {
+            use std::hash::Hash;
+
+            self.dimen.hash(state);
+        }
+
+        fn draw(
+            &self,
+            _renderer: &mut Renderer,
+            layout: Layout<'_>,
+            cursor_position: Point,
+        ) -> (Primitive, MouseCursor) {
+            let b = layout.bounds();
+
+            // R O Y G B I V
+            let color_r = [1.0, 0.0, 0.0, 1.0];
+            let color_o = [1.0, 0.5, 0.0, 1.0];
+            let color_y = [1.0, 1.0, 0.0, 1.0];
+            let color_g = [0.0, 1.0, 0.0, 1.0];
+            let color_gb = [0.0, 1.0, 0.5, 1.0];
+            let color_b = [0.0, 0.2, 1.0, 1.0];
+            let color_i = [0.5, 0.0, 1.0, 1.0];
+            let color_v = [0.75, 0.0, 0.5, 1.0];
+
+            let posn_center = {
+                if b.contains(cursor_position) {
+                    [cursor_position.x, cursor_position.y]
+                } else {
+                    [b.x + (b.width / 2.0), b.y + (b.height / 2.0)]
+                }
+            };
+
+            let posn_tl = [b.x, b.y];
+            let posn_t = [b.x + (b.width / 2.0), b.y];
+            let posn_tr = [b.x + b.width, b.y];
+            let posn_r = [b.x + b.width, b.y + (b.height / 2.0)];
+            let posn_br = [b.x + b.width, b.y + b.height];
+            let posn_b = [b.x + (b.width / 2.0), b.y + b.height];
+            let posn_bl = [b.x, b.y + b.height];
+            let posn_l = [b.x, b.y + (b.height / 2.0)];
+
+            (
+                Primitive::Geometry2D {
+                    geometry: Geometry2D {
+                        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,
+            )
+        }
+    }
+
+    impl<'a, Message> Into<Element<'a, Message, Renderer>> for Rainbow {
+        fn into(self) -> Element<'a, Message, Renderer> {
+            Element::new(self)
+        }
+    }
+}
+
+use iced::{
+    scrollable, settings::Window,  Align, Column, Container, Element,
+    Length, Sandbox, Scrollable, Settings,  Text,
+};
+use rainbow::Rainbow;
+
+pub fn main() {
+    Example::run(Settings {
+        window: Window {
+            size: (660, 660),
+            resizable: true,
+            decorations: true,
+        },
+    })
+}
+
+struct Example {
+    dimen: u16,
+    scroll: scrollable::State,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum Message {}
+
+impl Sandbox for Example {
+    type Message = Message;
+
+    fn new() -> Self {
+        Example {
+            dimen: 500,
+            scroll: scrollable::State::new(),
+        }
+    }
+
+    fn title(&self) -> String {
+        String::from("Custom 2D geometry - Iced")
+    }
+
+    fn update(&mut self, _: Message) {}
+
+    fn view(&mut self) -> Element<Message> {
+        let content = Column::new()
+            .padding(20)
+            .spacing(20)
+            .max_width(500)
+            .align_items(Align::Start)
+            .push(Rainbow::new(self.dimen))
+            .push(
+                Text::new(String::from("In this example we draw a custom widget Rainbow, using the \
+                Geometry2D primitive. This primitive supplies a list of triangles, expressed as vertices and indices."))
+                    .width(Length::Shrink),
+            )
+            .push(
+                Text::new(String::from("Move your cursor over it, and see the center vertex follow you!"))
+                    .width(Length::Shrink),
+            )
+            .push(
+                Text::new(String::from("Every Vertex2D defines its own color. You could use the \
+                Geometry2D primitive to render virtually any two-dimensional geometry for your widget."))
+                    .width(Length::Shrink),
+            );
+
+        let scrollable =
+            Scrollable::new(&mut self.scroll).push(Container::new(content));
+
+        Container::new(scrollable)
+            .width(Length::Fill)
+            .height(Length::Fill)
+            .center_x()
+            .center_y()
+            .into()
+    }
+}

native/src/lib.rs

@@ -55,7 +55,7 @@ mod user_interface;
 
 pub use iced_core::{
     Align, Background, Color, Command, Font, HorizontalAlignment, Length,
-    Point, Rectangle, Vector, VerticalAlignment,
+    Point, Rectangle, Vector, VerticalAlignment, Geometry2D, Vertex2D,
 };
 
 pub use clipboard::Clipboard;

wgpu/src/geometry.rs

@@ -0,0 +1,215 @@
+use crate::Transformation;
+use iced_native::{Geometry2D, Rectangle, Vertex2D};
+use std::mem;
+
+#[derive(Debug)]
+pub struct Pipeline {
+    pipeline: wgpu::RenderPipeline,
+    constants: wgpu::BindGroup,
+    constants_buffer: wgpu::Buffer,
+}
+
+impl Pipeline {
+    pub fn new(device: &mut wgpu::Device) -> Pipeline {
+        let constant_layout =
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                bindings: &[wgpu::BindGroupLayoutBinding {
+                    binding: 0,
+                    visibility: wgpu::ShaderStage::VERTEX,
+                    ty: wgpu::BindingType::UniformBuffer { dynamic: false },
+                }],
+            });
+
+        let constants_buffer = device
+            .create_buffer_mapped(
+                1,
+                wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
+            )
+            .fill_from_slice(&[Uniforms::default()]);
+
+        let constant_bind_group =
+            device.create_bind_group(&wgpu::BindGroupDescriptor {
+                layout: &constant_layout,
+                bindings: &[wgpu::Binding {
+                    binding: 0,
+                    resource: wgpu::BindingResource::Buffer {
+                        buffer: &constants_buffer,
+                        range: 0..std::mem::size_of::<Uniforms>() as u64,
+                    },
+                }],
+            });
+
+        let layout =
+            device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                bind_group_layouts: &[&constant_layout],
+            });
+
+        let vs = include_bytes!("shader/geom2d.vert.spv");
+        let vs_module = device.create_shader_module(
+            &wgpu::read_spirv(std::io::Cursor::new(&vs[..]))
+                .expect("Read quad vertex shader as SPIR-V"),
+        );
+
+        let fs = include_bytes!("shader/geom2d.frag.spv");
+        let fs_module = device.create_shader_module(
+            &wgpu::read_spirv(std::io::Cursor::new(&fs[..]))
+                .expect("Read quad fragment shader as SPIR-V"),
+        );
+
+        let pipeline =
+            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                layout: &layout,
+                vertex_stage: wgpu::ProgrammableStageDescriptor {
+                    module: &vs_module,
+                    entry_point: "main",
+                },
+                fragment_stage: Some(wgpu::ProgrammableStageDescriptor {
+                    module: &fs_module,
+                    entry_point: "main",
+                }),
+                rasterization_state: Some(wgpu::RasterizationStateDescriptor {
+                    front_face: wgpu::FrontFace::Cw,
+                    cull_mode: wgpu::CullMode::None,
+                    depth_bias: 0,
+                    depth_bias_slope_scale: 0.0,
+                    depth_bias_clamp: 0.0,
+                }),
+                primitive_topology: wgpu::PrimitiveTopology::TriangleList,
+                color_states: &[wgpu::ColorStateDescriptor {
+                    format: wgpu::TextureFormat::Bgra8UnormSrgb,
+                    color_blend: wgpu::BlendDescriptor {
+                        src_factor: wgpu::BlendFactor::SrcAlpha,
+                        dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                        operation: wgpu::BlendOperation::Add,
+                    },
+                    alpha_blend: wgpu::BlendDescriptor {
+                        src_factor: wgpu::BlendFactor::One,
+                        dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                        operation: wgpu::BlendOperation::Add,
+                    },
+                    write_mask: wgpu::ColorWrite::ALL,
+                }],
+                depth_stencil_state: None,
+                index_format: wgpu::IndexFormat::Uint16,
+                vertex_buffers: &[wgpu::VertexBufferDescriptor {
+                    stride: mem::size_of::<Vertex2D>() as u64,
+                    step_mode: wgpu::InputStepMode::Vertex,
+                    attributes: &[
+                        // Position
+                        wgpu::VertexAttributeDescriptor {
+                            shader_location: 0,
+                            format: wgpu::VertexFormat::Float2,
+                            offset: 0,
+                        },
+                        // Color
+                        wgpu::VertexAttributeDescriptor {
+                            shader_location: 1,
+                            format: wgpu::VertexFormat::Float4,
+                            offset: 4 * 2,
+                        },
+                    ],
+                }],
+                sample_count: 1,
+                sample_mask: !0,
+                alpha_to_coverage_enabled: false,
+            });
+
+        Pipeline {
+            pipeline,
+            constants: constant_bind_group,
+            constants_buffer,
+        }
+    }
+
+    pub fn draw(
+        &mut self,
+        device: &mut wgpu::Device,
+        encoder: &mut wgpu::CommandEncoder,
+        target: &wgpu::TextureView,
+        transformation: Transformation,
+        scale: f32,
+        geometries: &Vec<Geometry2D>,
+        bounds: Rectangle<u32>,
+    ) {
+        let uniforms = Uniforms {
+            transform: transformation.into(),
+            scale,
+        };
+
+        let constants_buffer = device
+            .create_buffer_mapped(1, wgpu::BufferUsage::COPY_SRC)
+            .fill_from_slice(&[uniforms]);
+
+        encoder.copy_buffer_to_buffer(
+            &constants_buffer,
+            0,
+            &self.constants_buffer,
+            0,
+            std::mem::size_of::<Uniforms>() as u64,
+        );
+
+        for geom in geometries {
+            let vertices_buffer = device
+                .create_buffer_mapped(
+                    geom.vertices.len(),
+                    wgpu::BufferUsage::VERTEX,
+                )
+                .fill_from_slice(&geom.vertices);
+
+            let indices_buffer = device
+                .create_buffer_mapped(
+                    geom.indices.len(),
+                    wgpu::BufferUsage::INDEX,
+                )
+                .fill_from_slice(&geom.indices);
+
+            let mut render_pass =
+                encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                    color_attachments: &[
+                        wgpu::RenderPassColorAttachmentDescriptor {
+                            attachment: target,
+                            resolve_target: None,
+                            load_op: wgpu::LoadOp::Load,
+                            store_op: wgpu::StoreOp::Store,
+                            clear_color: wgpu::Color {
+                                r: 0.0,
+                                g: 0.0,
+                                b: 0.0,
+                                a: 0.0,
+                            },
+                        },
+                    ],
+                    depth_stencil_attachment: None,
+                });
+
+            render_pass.set_pipeline(&self.pipeline);
+            render_pass.set_bind_group(0, &self.constants, &[]);
+            render_pass.set_index_buffer(&indices_buffer, 0);
+            render_pass.set_vertex_buffers(0, &[(&vertices_buffer, 0)]);
+            render_pass.set_scissor_rect(
+                bounds.x,
+                bounds.y,
+                bounds.width,
+                bounds.height,
+            );
+
+            render_pass.draw_indexed(0..geom.indices.len() as u32, 0, 0..1);
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+struct Uniforms {
+    transform: [f32; 16],
+    scale: f32,
+}
+
+impl Default for Uniforms {
+    fn default() -> Self {
+        Self {
+            transform: *Transformation::identity().as_ref(),
+            scale: 1.0,
+        }
+    }
+}

wgpu/src/lib.rs

@@ -30,6 +30,7 @@ mod quad;
 mod renderer;
 mod text;
 mod transformation;
+mod geometry;
 
 pub(crate) use crate::image::Image;
 pub(crate) use quad::Quad;

wgpu/src/primitive.rs

@@ -1,6 +1,6 @@
 use iced_native::{
     image, svg, Background, Color, Font, HorizontalAlignment, Rectangle,
-    Vector, VerticalAlignment,
+    Vector, VerticalAlignment, Geometry2D,
 };
 
 /// A rendering primitive.
@@ -63,6 +63,11 @@ pub enum Primitive {
         /// The content of the clip
         content: Box<Primitive>,
     },
+    /// A low-level geometry primitive
+    Geometry2D {
+        /// The vertices and indices of the geometry
+        geometry: Geometry2D,
+    },
 }
 
 impl Default for Primitive {

wgpu/src/renderer.rs

@@ -1,7 +1,10 @@
-use crate::{image, quad, text, Image, Primitive, Quad, Transformation};
+use crate::{
+    geometry, image, quad, text, Image, Primitive, Quad, Transformation,
+};
 use iced_native::{
     renderer::{Debugger, Windowed},
-    Background, Color, Layout, MouseCursor, Point, Rectangle, Vector, Widget,
+    Background, Color, Geometry2D, Layout, MouseCursor, Point, Rectangle,
+    Vector, Widget,
 };
 
 use wgpu::{
@@ -24,6 +27,7 @@ pub struct Renderer {
     quad_pipeline: quad::Pipeline,
     image_pipeline: crate::image::Pipeline,
     text_pipeline: text::Pipeline,
+    geometry_pipeline: crate::geometry::Pipeline,
 }
 
 struct Layer<'a> {
@@ -31,6 +35,7 @@ struct Layer<'a> {
     offset: Vector<u32>,
     quads: Vec<Quad>,
     images: Vec<Image>,
+    geometries: Vec<Geometry2D>,
     text: Vec<wgpu_glyph::Section<'a>>,
 }
 
@@ -42,6 +47,7 @@ impl<'a> Layer<'a> {
             quads: Vec::new(),
             images: Vec::new(),
             text: Vec::new(),
+            geometries: Vec::new(),
         }
     }
 }
@@ -64,6 +70,7 @@ impl Renderer {
         let text_pipeline = text::Pipeline::new(&mut device);
         let quad_pipeline = quad::Pipeline::new(&mut device);
         let image_pipeline = crate::image::Pipeline::new(&mut device);
+        let geometry_pipeline = geometry::Pipeline::new(&mut device);
 
         Self {
             device,
@@ -71,6 +78,7 @@ impl Renderer {
             quad_pipeline,
             image_pipeline,
             text_pipeline,
+            geometry_pipeline,
         }
     }
 
@@ -244,6 +252,9 @@ impl Renderer {
                     scale: [bounds.width, bounds.height],
                 });
             }
+            Primitive::Geometry2D { geometry } => {
+                layer.geometries.push(geometry.clone());
+            }
             Primitive::Clip {
                 bounds,
                 offset,
@@ -401,6 +412,24 @@ impl Renderer {
                 },
             );
         }
+
+        if layer.geometries.len() > 0 {
+            let translated = transformation
+                * Transformation::translate(
+                    -(layer.offset.x as f32) * dpi,
+                    -(layer.offset.y as f32) * dpi,
+                );
+
+            self.geometry_pipeline.draw(
+                &mut self.device,
+                encoder,
+                target,
+                translated,
+                dpi,
+                &layer.geometries,
+                bounds,
+            );
+        }
     }
 }
 

wgpu/src/shader/geom2d.frag

@@ -0,0 +1,8 @@
+#version 450
+
+layout(location = 0) in vec4 i_Color;
+layout(location = 0) out vec4 o_Color;
+
+void main() {
+    o_Color = i_Color;
+}

wgpu/src/shader/geom2d.vert

@@ -0,0 +1,17 @@
+#version 450
+
+layout(location = 0) in vec2 i_Position;
+layout(location = 1) in vec4 i_Color;
+
+layout(location = 0) out vec4 o_Color;
+
+layout (set = 0, binding = 0) uniform Globals {
+    mat4 u_Transform;
+    float u_Scale;
+};
+
+void main() {
+    vec2 p_Position = i_Position * u_Scale;
+    gl_Position = u_Transform * vec4(p_Position, 0.0, 1.0);
+    o_Color = i_Color;
+}