reivilibre/iced-mobile
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rename Geometry2D to Mesh2D and move it to iced_wgpu

Browse Source
This commit is contained in:
Héctor Ramón Jiménez 2020-01-02 19:25:00 +01:00
parent 0d620b7701
commit 5ca98b113e
12 changed files with 184 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
core/src/geometry.rs
View File

@ -1,20 +0,0 @@
/// 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>,
}

2
core/src/lib.rs
View File

@ -23,7 +23,6 @@ mod length;
mod point;
mod rectangle;
mod vector;
mod geometry;
pub use align::{Align, HorizontalAlignment, VerticalAlignment};
pub use background::Background;
@ -33,7 +32,6 @@ 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;

194
examples/geometry.rs
View File

@ -11,24 +11,25 @@ mod rainbow {
// 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,
layout, Element, Hasher, Layout, Length, MouseCursor, Point, Size,
Widget,
};
use iced_wgpu::{
triangle::{Mesh2D, Vertex2D},
Primitive, Renderer,
};
use iced_wgpu::{Primitive, Renderer};
pub struct Rainbow {
dimen: u16,
}
pub struct Rainbow;
impl Rainbow {
pub fn new(dimen: u16) -> Self {
Self { dimen }
pub fn new() -> Self {
Self
}
}
impl<Message> Widget<Message, Renderer> for Rainbow {
fn width(&self) -> Length {
Length::Shrink
Length::Fill
}
fn height(&self) -> Length {
@ -38,19 +39,14 @@ mod rainbow {
fn layout(
&self,
_renderer: &Renderer,
_limits: &layout::Limits,
limits: &layout::Limits,
) -> layout::Node {
layout::Node::new(Size::new(
f32::from(self.dimen),
f32::from(self.dimen),
))
let size = limits.width(Length::Fill).resolve(Size::ZERO);
layout::Node::new(Size::new(size.width, size.width))
}
fn hash_layout(&self, state: &mut Hasher) {
use std::hash::Hash;
self.dimen.hash(state);
}
fn hash_layout(&self, _state: &mut Hasher) {}
fn draw(
&self,
@ -88,58 +84,56 @@ mod rainbow {
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
],
},
},
Primitive::Mesh2D(std::sync::Arc::new(Mesh2D {
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,
)
}
@ -153,35 +147,24 @@ mod rainbow {
}
use iced::{
scrollable, settings::Window, Align, Column, Container, Element,
Length, Sandbox, Scrollable, Settings, Text,
scrollable, 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,
},
})
Example::run(Settings::default())
}
struct Example {
dimen: u16,
scroll: scrollable::State,
}
#[derive(Debug, Clone, Copy)]
enum Message {}
impl Sandbox for Example {
type Message = Message;
type Message = ();
fn new() -> Self {
Example {
dimen: 500,
scroll: scrollable::State::new(),
}
}
@ -190,37 +173,36 @@ impl Sandbox for Example {
String::from("Custom 2D geometry - Iced")
}
fn update(&mut self, _: Message) {}
fn update(&mut self, _: ()) {}
fn view(&mut self) -> Element<Message> {
fn view(&mut self) -> Element<()> {
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),
);
.push(Rainbow::new())
.push(Text::new(
"In this example we draw a custom widget Rainbow, using \
the Mesh2D primitive. This primitive supplies a list of \
triangles, expressed as vertices and indices.",
))
.push(Text::new(
"Move your cursor over it, and see the center vertex \
follow you!",
))
.push(Text::new(
"Every Vertex2D defines its own color. You could use the \
Mesh2D primitive to render virtually any two-dimensional \
geometry for your widget.",
));
let scrollable =
Scrollable::new(&mut self.scroll).push(Container::new(content));
let scrollable = Scrollable::new(&mut self.scroll)
.push(Container::new(content).width(Length::Fill).center_x());
Container::new(scrollable)
.width(Length::Fill)
.height(Length::Fill)
.center_x()
.center_y()
.into()
}

2
native/src/lib.rs
View File

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

3
wgpu/src/lib.rs
View File

@ -24,13 +24,14 @@
#![deny(unused_results)]
#![deny(unsafe_code)]
#![deny(rust_2018_idioms)]
pub mod triangle;
mod image;
mod primitive;
mod quad;
mod renderer;
mod text;
mod transformation;
mod geometry;
pub(crate) use crate::image::Image;
pub(crate) use quad::Quad;

14
wgpu/src/primitive.rs
View File

@ -1,8 +1,11 @@
use iced_native::{
image, svg, Background, Color, Font, HorizontalAlignment, Rectangle,
Vector, VerticalAlignment, Geometry2D,
Vector, VerticalAlignment,
};
use crate::triangle;
use std::sync::Arc;
/// A rendering primitive.
#[derive(Debug, Clone)]
pub enum Primitive {
@ -63,11 +66,10 @@ 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,
},
/// A low-level primitive to render a mesh of triangles.
///
/// It can be used to render many kinds of geometry freely.
Mesh2D(Arc<triangle::Mesh2D>),
}
impl Default for Primitive {

57
wgpu/src/renderer.rs
View File

@ -1,12 +1,11 @@
use crate::{
geometry, image, quad, text, Image, Primitive, Quad, Transformation,
image, quad, text, triangle, Image, Primitive, Quad, Transformation,
};
use iced_native::{
renderer::{Debugger, Windowed},
Background, Color, Geometry2D, Layout, MouseCursor, Point, Rectangle,
Vector, Widget,
Background, Color, Layout, MouseCursor, Point, Rectangle, Vector, Widget,
};
use std::sync::Arc;
use wgpu::{
Adapter, BackendBit, CommandEncoderDescriptor, Device, DeviceDescriptor,
Extensions, Limits, PowerPreference, Queue, RequestAdapterOptions,
@ -27,7 +26,7 @@ pub struct Renderer {
quad_pipeline: quad::Pipeline,
image_pipeline: crate::image::Pipeline,
text_pipeline: text::Pipeline,
geometry_pipeline: crate::geometry::Pipeline,
triangle_pipeline: crate::triangle::Pipeline,
}
struct Layer<'a> {
@ -35,7 +34,7 @@ struct Layer<'a> {
offset: Vector<u32>,
quads: Vec<Quad>,
images: Vec<Image>,
geometries: Vec<Geometry2D>,
meshes: Vec<Arc<triangle::Mesh2D>>,
text: Vec<wgpu_glyph::Section<'a>>,
}
@ -47,7 +46,7 @@ impl<'a> Layer<'a> {
quads: Vec::new(),
images: Vec::new(),
text: Vec::new(),
geometries: Vec::new(),
meshes: Vec::new(),
}
}
}
@ -70,7 +69,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);
let triangle_pipeline = triangle::Pipeline::new(&mut device);
Self {
device,
@ -78,7 +77,7 @@ impl Renderer {
quad_pipeline,
image_pipeline,
text_pipeline,
geometry_pipeline,
triangle_pipeline,
}
}
@ -252,8 +251,8 @@ impl Renderer {
scale: [bounds.width, bounds.height],
});
}
Primitive::Geometry2D { geometry } => {
layer.geometries.push(geometry.clone());
Primitive::Mesh2D(mesh) => {
layer.meshes.push(mesh.clone());
}
Primitive::Clip {
bounds,
@ -333,6 +332,24 @@ impl Renderer {
) {
let bounds = layer.bounds * dpi;
if layer.meshes.len() > 0 {
let translated = transformation
* Transformation::translate(
-(layer.offset.x as f32) * dpi,
-(layer.offset.y as f32) * dpi,
);
self.triangle_pipeline.draw(
&mut self.device,
encoder,
target,
translated,
dpi,
&layer.meshes,
bounds,
);
}
if layer.quads.len() > 0 {
self.quad_pipeline.draw(
&mut self.device,
@ -412,24 +429,6 @@ 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,
);
}
}
}

0
wgpu/src/shader/geom2d.frag → wgpu/src/shader/triangle.frag
View File

BIN
wgpu/src/shader/geom2d.frag.spv → wgpu/src/shader/triangle.frag.spv
View File

Binary file not shown.

0
wgpu/src/shader/geom2d.vert → wgpu/src/shader/triangle.vert
View File

BIN
wgpu/src/shader/geom2d.vert.spv → wgpu/src/shader/triangle.vert.spv
View File

Binary file not shown.

90
wgpu/src/geometry.rs → wgpu/src/triangle.rs
View File

@ -1,9 +1,10 @@
//! Draw meshes of triangles.
use crate::Transformation;
use iced_native::{Geometry2D, Rectangle, Vertex2D};
use std::mem;
use iced_native::Rectangle;
use std::{mem, sync::Arc};
#[derive(Debug)]
pub struct Pipeline {
pub(crate) struct Pipeline {
pipeline: wgpu::RenderPipeline,
constants: wgpu::BindGroup,
constants_buffer: wgpu::Buffer,
@ -44,16 +45,16 @@ impl Pipeline {
bind_group_layouts: &[&constant_layout],
});
let vs = include_bytes!("shader/geom2d.vert.spv");
let vs = include_bytes!("shader/triangle.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"),
.expect("Read triangle vertex shader as SPIR-V"),
);
let fs = include_bytes!("shader/geom2d.frag.spv");
let fs = include_bytes!("shader/triangle.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"),
.expect("Read triangle fragment shader as SPIR-V"),
);
let pipeline =
@ -128,7 +129,7 @@ impl Pipeline {
target: &wgpu::TextureView,
transformation: Transformation,
scale: f32,
geometries: &Vec<Geometry2D>,
meshes: &Vec<Arc<Mesh2D>>,
bounds: Rectangle<u32>,
) {
let uniforms = Uniforms {
@ -148,39 +149,39 @@ impl Pipeline {
std::mem::size_of::<Uniforms>() as u64,
);
for geom in geometries {
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,
});
for mesh in meshes {
let vertices_buffer = device
.create_buffer_mapped(
geom.vertices.len(),
mesh.vertices.len(),
wgpu::BufferUsage::VERTEX,
)
.fill_from_slice(&geom.vertices);
.fill_from_slice(&mesh.vertices);
let indices_buffer = device
.create_buffer_mapped(
geom.indices.len(),
mesh.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,
});
.fill_from_slice(&mesh.indices);
render_pass.set_pipeline(&self.pipeline);
render_pass.set_bind_group(0, &self.constants, &[]);
@ -193,7 +194,7 @@ impl Pipeline {
bounds.height,
);
render_pass.draw_indexed(0..geom.indices.len() as u32, 0, 0..1);
render_pass.draw_indexed(0..mesh.indices.len() as u32, 0, 0..1);
}
}
}
@ -213,3 +214,26 @@ impl Default for Uniforms {
}
}
}
/// A two-dimensional vertex with some color in __linear__ RGBA.
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct Vertex2D {
/// The vertex position
pub position: [f32; 2],
/// The vertex color in __linear__ RGBA.
pub color: [f32; 4],
}
/// A set of [`Vertex2D`] and indices representing a list of triangles.
///
/// [`Vertex2D`]: struct.Vertex2D.html
#[derive(Clone, Debug)]
pub struct Mesh2D {
/// The vertices of the mesh
pub vertices: Vec<Vertex2D>,
/// The list of vertex indices that defines the triangles of the mesh.
///
/// Therefore, this list should always have a length that is a multiple of 3.
pub indices: Vec<u16>,
}