summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--core/src/geometry.rs20
-rw-r--r--core/src/lib.rs2
-rw-r--r--examples/geometry.rs227
-rw-r--r--native/src/lib.rs2
-rw-r--r--native/src/widget/geometry.rs0
-rw-r--r--wgpu/src/geometry.rs215
-rw-r--r--wgpu/src/lib.rs1
-rw-r--r--wgpu/src/primitive.rs7
-rw-r--r--wgpu/src/renderer.rs33
-rw-r--r--wgpu/src/shader/geom2d.frag8
-rw-r--r--wgpu/src/shader/geom2d.frag.spvbin0 -> 372 bytes
-rw-r--r--wgpu/src/shader/geom2d.vert17
-rw-r--r--wgpu/src/shader/geom2d.vert.spvbin0 -> 1468 bytes
13 files changed, 528 insertions, 4 deletions
diff --git a/core/src/geometry.rs b/core/src/geometry.rs
new file mode 100644
index 00000000..f04ce42e
--- /dev/null
+++ b/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>,
+}
diff --git a/core/src/lib.rs b/core/src/lib.rs
index 821b09c1..881f56c9 100644
--- a/core/src/lib.rs
+++ b/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;
diff --git a/examples/geometry.rs b/examples/geometry.rs
new file mode 100644
index 00000000..feb7684e
--- /dev/null
+++ b/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()
+ }
+}
diff --git a/native/src/lib.rs b/native/src/lib.rs
index 8dcacb2b..6f6af159 100644
--- a/native/src/lib.rs
+++ b/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;
diff --git a/native/src/widget/geometry.rs b/native/src/widget/geometry.rs
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/native/src/widget/geometry.rs
diff --git a/wgpu/src/geometry.rs b/wgpu/src/geometry.rs
new file mode 100644
index 00000000..f79e9c43
--- /dev/null
+++ b/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,
+ }
+ }
+}
diff --git a/wgpu/src/lib.rs b/wgpu/src/lib.rs
index 9f9ed8db..7587be77 100644
--- a/wgpu/src/lib.rs
+++ b/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;
diff --git a/wgpu/src/primitive.rs b/wgpu/src/primitive.rs
index 6c61f800..06121262 100644
--- a/wgpu/src/primitive.rs
+++ b/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 {
diff --git a/wgpu/src/renderer.rs b/wgpu/src/renderer.rs
index 365ef1ef..3cfd746d 100644
--- a/wgpu/src/renderer.rs
+++ b/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,
+ );
+ }
}
}
diff --git a/wgpu/src/shader/geom2d.frag b/wgpu/src/shader/geom2d.frag
new file mode 100644
index 00000000..e39c45e7
--- /dev/null
+++ b/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;
+}
diff --git a/wgpu/src/shader/geom2d.frag.spv b/wgpu/src/shader/geom2d.frag.spv
new file mode 100644
index 00000000..c0165bca
--- /dev/null
+++ b/wgpu/src/shader/geom2d.frag.spv
Binary files differ
diff --git a/wgpu/src/shader/geom2d.vert b/wgpu/src/shader/geom2d.vert
new file mode 100644
index 00000000..fd86ecd6
--- /dev/null
+++ b/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;
+}
diff --git a/wgpu/src/shader/geom2d.vert.spv b/wgpu/src/shader/geom2d.vert.spv
new file mode 100644
index 00000000..c15c7451
--- /dev/null
+++ b/wgpu/src/shader/geom2d.vert.spv
Binary files differ
generated by cgit (git 2.34.1) at 2025-04-15 23:11:59 +0000