me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge branch 'master' into feature/image-from-bytes

Browse source
This commit is contained in:
Héctor Ramón Jiménez 2019-12-04 04:01:12 +01:00
commit 561c3641c6
24 changed files with 454 additions and 166 deletions
Download patch file Download diff file Expand all files Collapse all files

2
wgpu/src/image.rs
View file

@ -491,6 +491,7 @@ pub struct Image {
pub scale: [f32; 2],
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct Vertex {
_position: [f32; 2],
@ -513,6 +514,7 @@ const QUAD_VERTS: [Vertex; 4] = [
},
];
#[repr(C)]
#[derive(Clone, Copy)]
struct Instance {
_position: [f32; 2],

2
wgpu/src/quad.rs
View file

@ -248,6 +248,7 @@ impl Pipeline {
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct Vertex {
_position: [f32; 2],
@ -270,6 +271,7 @@ const QUAD_VERTS: [Vertex; 4] = [
},
];
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct Quad {
pub position: [f32; 2],

2
wgpu/src/renderer.rs
View file

@ -49,7 +49,7 @@ impl<'a> Layer<'a> {
impl Renderer {
fn new() -> Self {
let adapter = Adapter::request(&RequestAdapterOptions {
power_preference: PowerPreference::LowPower,
power_preference: PowerPreference::Default,
backends: BackendBit::all(),
})
.expect("Request adapter");

120
wgpu/src/renderer/widget/scrollable.rs
View file

@ -1,45 +1,58 @@
use crate::{Primitive, Renderer};
use iced_native::{
scrollable, Background, MouseCursor, Point, Rectangle, Vector,
};
use iced_native::{scrollable, Background, MouseCursor, Rectangle, Vector};
const SCROLLBAR_WIDTH: u16 = 10;
const SCROLLBAR_MARGIN: u16 = 2;
fn scrollbar_bounds(bounds: Rectangle) -> Rectangle {
Rectangle {
x: bounds.x + bounds.width
- f32::from(SCROLLBAR_WIDTH + 2 * SCROLLBAR_MARGIN),
y: bounds.y,
width: f32::from(SCROLLBAR_WIDTH + 2 * SCROLLBAR_MARGIN),
height: bounds.height,
}
}
impl scrollable::Renderer for Renderer {
fn is_mouse_over_scrollbar(
fn scrollbar(
&self,
bounds: Rectangle,
content_bounds: Rectangle,
cursor_position: Point,
) -> bool {
content_bounds.height > bounds.height
&& scrollbar_bounds(bounds).contains(cursor_position)
offset: u32,
) -> Option<scrollable::Scrollbar> {
if content_bounds.height > bounds.height {
let scrollbar_bounds = Rectangle {
x: bounds.x + bounds.width
- f32::from(SCROLLBAR_WIDTH + 2 * SCROLLBAR_MARGIN),
y: bounds.y,
width: f32::from(SCROLLBAR_WIDTH + 2 * SCROLLBAR_MARGIN),
height: bounds.height,
};
let ratio = bounds.height / content_bounds.height;
let scrollbar_height = bounds.height * ratio;
let y_offset = offset as f32 * ratio;
let scroller_bounds = Rectangle {
x: scrollbar_bounds.x + f32::from(SCROLLBAR_MARGIN),
y: scrollbar_bounds.y + y_offset,
width: scrollbar_bounds.width - f32::from(2 * SCROLLBAR_MARGIN),
height: scrollbar_height,
};
Some(scrollable::Scrollbar {
bounds: scrollbar_bounds,
scroller: scrollable::Scroller {
bounds: scroller_bounds,
},
})
} else {
None
}
}
fn draw(
&mut self,
state: &scrollable::State,
bounds: Rectangle,
content_bounds: Rectangle,
_content_bounds: Rectangle,
is_mouse_over: bool,
is_mouse_over_scrollbar: bool,
scrollbar: Option<scrollable::Scrollbar>,
offset: u32,
(content, mouse_cursor): Self::Output,
) -> Self::Output {
let is_content_overflowing = content_bounds.height > bounds.height;
let scrollbar_bounds = scrollbar_bounds(bounds);
let clip = Primitive::Clip {
bounds,
offset: Vector::new(0, offset),
@ -47,51 +60,46 @@ impl scrollable::Renderer for Renderer {
};
(
if is_content_overflowing
&& (is_mouse_over || state.is_scrollbar_grabbed())
{
let ratio = bounds.height / content_bounds.height;
let scrollbar_height = bounds.height * ratio;
let y_offset = offset as f32 * ratio;
let scrollbar = Primitive::Quad {
bounds: Rectangle {
x: scrollbar_bounds.x + f32::from(SCROLLBAR_MARGIN),
y: scrollbar_bounds.y + y_offset,
width: scrollbar_bounds.width
- f32::from(2 * SCROLLBAR_MARGIN),
height: scrollbar_height,
},
background: Background::Color([0.0, 0.0, 0.0, 0.7].into()),
border_radius: 5,
};
if is_mouse_over_scrollbar || state.is_scrollbar_grabbed() {
let scrollbar_background = Primitive::Quad {
bounds: Rectangle {
x: scrollbar_bounds.x + f32::from(SCROLLBAR_MARGIN),
width: scrollbar_bounds.width
- f32::from(2 * SCROLLBAR_MARGIN),
..scrollbar_bounds
},
if let Some(scrollbar) = scrollbar {
if is_mouse_over || state.is_scroller_grabbed() {
let scroller = Primitive::Quad {
bounds: scrollbar.scroller.bounds,
background: Background::Color(
[0.0, 0.0, 0.0, 0.3].into(),
[0.0, 0.0, 0.0, 0.7].into(),
),
border_radius: 5,
};
Primitive::Group {
primitives: vec![clip, scrollbar_background, scrollbar],
if is_mouse_over_scrollbar || state.is_scroller_grabbed() {
let scrollbar = Primitive::Quad {
bounds: Rectangle {
x: scrollbar.bounds.x
+ f32::from(SCROLLBAR_MARGIN),
width: scrollbar.bounds.width
- f32::from(2 * SCROLLBAR_MARGIN),
..scrollbar.bounds
},
background: Background::Color(
[0.0, 0.0, 0.0, 0.3].into(),
),
border_radius: 5,
};
Primitive::Group {
primitives: vec![clip, scrollbar, scroller],
}
} else {
Primitive::Group {
primitives: vec![clip, scroller],
}
}
} else {
Primitive::Group {
primitives: vec![clip, scrollbar],
}
clip
}
} else {
clip
},
if is_mouse_over_scrollbar || state.is_scrollbar_grabbed() {
if is_mouse_over_scrollbar || state.is_scroller_grabbed() {
MouseCursor::Idle
} else {
mouse_cursor

2
wgpu/src/renderer/widget/text_input.rs
View file

@ -45,7 +45,7 @@ impl text_input::Renderer for Renderer {
height: bounds.height - 2.0,
},
background: Background::Color(Color::WHITE),
border_radius: 5,
border_radius: 4,
};
let size = f32::from(size);

46
wgpu/src/text.rs
View file

@ -11,6 +11,8 @@ pub const BUILTIN_ICONS: iced_native::Font = iced_native::Font::External {
pub const CHECKMARK_ICON: char = '\u{F00C}';
const FALLBACK_FONT: &[u8] = include_bytes!("../fonts/Lato-Regular.ttf");
#[derive(Debug)]
pub struct Pipeline {
draw_brush: RefCell<wgpu_glyph::GlyphBrush<'static, ()>>,
@ -26,24 +28,31 @@ impl Pipeline {
let default_font = font_source
.load(&[font::Family::SansSerif, font::Family::Serif])
.expect("Find sans-serif or serif font");
.unwrap_or_else(|_| FALLBACK_FONT.to_vec());
let mono_font = font_source
.load(&[font::Family::Monospace])
.expect("Find monospace font");
let load_glyph_brush = |font: Vec<u8>| {
let builder =
wgpu_glyph::GlyphBrushBuilder::using_fonts_bytes(vec![
font.clone()
])?;
let draw_brush =
wgpu_glyph::GlyphBrushBuilder::using_fonts_bytes(vec![
mono_font,
default_font.clone(),
])
Ok((
builder,
glyph_brush::GlyphBrushBuilder::using_font_bytes(font).build(),
))
};
let (brush_builder, measure_brush) = load_glyph_brush(default_font)
.unwrap_or_else(|_: wgpu_glyph::rusttype::Error| {
log::warn!("System font failed to load. Falling back to embedded font...");
load_glyph_brush(FALLBACK_FONT.to_vec()).expect("Load fallback font")
});
let draw_brush = brush_builder
.initial_cache_size((2048, 2048))
.build(device, wgpu::TextureFormat::Bgra8UnormSrgb);
let measure_brush =
glyph_brush::GlyphBrushBuilder::using_font_bytes(default_font)
.build();
Pipeline {
draw_brush: RefCell::new(draw_brush),
draw_font_map: RefCell::new(HashMap::new()),
@ -95,14 +104,7 @@ impl Pipeline {
text: content,
scale: wgpu_glyph::Scale { x: size, y: size },
bounds: (bounds.width, bounds.height),
// TODO: This is a bit hacky. We are loading the debug font as the
// first font in the `draw_brush`. The `measure_brush` does not
// contain this, hence we subtract 1.
//
// This should go away once we unify `draw_brush` and
// `measure_brush`.
font_id: wgpu_glyph::FontId(font_id - 1),
font_id: wgpu_glyph::FontId(font_id),
..Default::default()
};
@ -143,7 +145,7 @@ impl Pipeline {
pub fn find_font(&self, font: iced_native::Font) -> wgpu_glyph::FontId {
match font {
iced_native::Font::Default => wgpu_glyph::FontId(1),
iced_native::Font::Default => wgpu_glyph::FontId(0),
iced_native::Font::External { name, bytes } => {
if let Some(font_id) = self.draw_font_map.borrow().get(name) {
return *font_id;