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

Merge pull request #181 from Imberflur/improvement/update-winit

Browse Source 
Update `winit` to `0.21`
This commit is contained in:
Héctor Ramón 2020-02-08 20:02:31 +01:00 committed by GitHub
commit 95880ca74b
9 changed files with 126 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
native/src/window/renderer.rs
View File

@ -39,9 +39,9 @@ pub trait Target {
/// [`Target`]: trait.Target.html
fn new<W: HasRawWindowHandle>(
window: &W,
width: u16,
height: u16,
dpi: f32,
width: u32,
height: u32,
scale_factor: f64,
renderer: &Self::Renderer,
) -> Self;
@ -50,9 +50,9 @@ pub trait Target {
/// [`Target`]: trait.Target.html
fn resize(
&mut self,
width: u16,
height: u16,
dpi: f32,
width: u32,
height: u32,
scale_factor: f64,
renderer: &Self::Renderer,
);
}

44
wgpu/src/renderer.rs
View File

@ -92,7 +92,7 @@ impl Renderer {
log::debug!("Drawing");
let (width, height) = target.dimensions();
let dpi = target.dpi();
let scale_factor = target.scale_factor();
let transformation = target.transformation();
let frame = target.next_frame();
@ -132,7 +132,13 @@ impl Renderer {
self.draw_overlay(overlay, &mut layers);
for layer in layers {
self.flush(dpi, transformation, &layer, &mut encoder, &frame.view);
self.flush(
scale_factor,
transformation,
&layer,
&mut encoder,
&frame.view,
);
}
self.queue.submit(&[encoder.finish()]);
@ -330,19 +336,19 @@ impl Renderer {
fn flush(
&mut self,
dpi: f32,
scale_factor: f32,
transformation: Transformation,
layer: &Layer<'_>,
encoder: &mut wgpu::CommandEncoder,
target: &wgpu::TextureView,
) {
let bounds = layer.bounds * dpi;
let bounds = layer.bounds * scale_factor;
if layer.meshes.len() > 0 {
let translated = transformation
* Transformation::translate(
-(layer.offset.x as f32) * dpi,
-(layer.offset.y as f32) * dpi,
-(layer.offset.x as f32) * scale_factor,
-(layer.offset.y as f32) * scale_factor,
);
self.triangle_pipeline.draw(
@ -350,7 +356,7 @@ impl Renderer {
encoder,
target,
translated,
dpi,
scale_factor,
&layer.meshes,
bounds,
);
@ -362,7 +368,7 @@ impl Renderer {
encoder,
&layer.quads,
transformation,
dpi,
scale_factor,
bounds,
target,
);
@ -370,7 +376,7 @@ impl Renderer {
if layer.images.len() > 0 {
let translated_and_scaled = transformation
* Transformation::scale(dpi, dpi)
* Transformation::scale(scale_factor, scale_factor)
* Transformation::translate(
-(layer.offset.x as f32),
-(layer.offset.y as f32),
@ -383,7 +389,7 @@ impl Renderer {
translated_and_scaled,
bounds,
target,
dpi,
scale_factor,
);
}
@ -396,25 +402,25 @@ impl Renderer {
// bit "jumpy". We may be able to do better once we improve
// our text rendering/caching pipeline.
screen_position: (
(text.screen_position.0 * dpi).round(),
(text.screen_position.1 * dpi).round(),
(text.screen_position.0 * scale_factor).round(),
(text.screen_position.1 * scale_factor).round(),
),
// TODO: Fix precision issues with some DPI factors.
// TODO: Fix precision issues with some scale factors.
//
// The `ceil` here can cause some words to render on the
// same line when they should not.
//
// Ideally, `wgpu_glyph` should be able to compute layout
// using logical positions, and then apply the proper
// DPI scaling. This would ensure that both measuring and
// rendering follow the same layout rules.
// scaling when rendering. This would ensure that both
// measuring and rendering follow the same layout rules.
bounds: (
(text.bounds.0 * dpi).ceil(),
(text.bounds.1 * dpi).ceil(),
(text.bounds.0 * scale_factor).ceil(),
(text.bounds.1 * scale_factor).ceil(),
),
scale: wgpu_glyph::Scale {
x: text.scale.x * dpi,
y: text.scale.y * dpi,
x: text.scale.x * scale_factor,
y: text.scale.y * scale_factor,
},
..*text
};

36
wgpu/src/renderer/target.rs
View File

@ -7,20 +7,20 @@ use raw_window_handle::HasRawWindowHandle;
#[derive(Debug)]
pub struct Target {
surface: wgpu::Surface,
width: u16,
height: u16,
dpi: f32,
width: u32,
height: u32,
scale_factor: f32,
transformation: Transformation,
swap_chain: wgpu::SwapChain,
}
impl Target {
pub(crate) fn dimensions(&self) -> (u16, u16) {
pub(crate) fn dimensions(&self) -> (u32, u32) {
(self.width, self.height)
}
pub(crate) fn dpi(&self) -> f32 {
self.dpi
pub(crate) fn scale_factor(&self) -> f32 {
self.scale_factor
}
pub(crate) fn transformation(&self) -> Transformation {
@ -37,9 +37,9 @@ impl window::Target for Target {
fn new<W: HasRawWindowHandle>(
window: &W,
width: u16,
height: u16,
dpi: f32,
width: u32,
height: u32,
scale_factor: f64,
renderer: &Renderer,
) -> Target {
let surface = wgpu::Surface::create(window);
@ -50,7 +50,7 @@ impl window::Target for Target {
surface,
width,
height,
dpi,
scale_factor: scale_factor as f32,
transformation: Transformation::orthographic(width, height),
swap_chain,
}
@ -58,14 +58,14 @@ impl window::Target for Target {
fn resize(
&mut self,
width: u16,
height: u16,
dpi: f32,
width: u32,
height: u32,
scale_factor: f64,
renderer: &Renderer,
) {
self.width = width;
self.height = height;
self.dpi = dpi;
self.scale_factor = scale_factor as f32;
self.transformation = Transformation::orthographic(width, height);
self.swap_chain =
new_swap_chain(&self.surface, width, height, &renderer.device);
@ -74,8 +74,8 @@ impl window::Target for Target {
fn new_swap_chain(
surface: &wgpu::Surface,
width: u16,
height: u16,
width: u32,
height: u32,
device: &wgpu::Device,
) -> wgpu::SwapChain {
device.create_swap_chain(
@ -83,8 +83,8 @@ fn new_swap_chain(
&wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::OUTPUT_ATTACHMENT,
format: wgpu::TextureFormat::Bgra8UnormSrgb,
width: u32::from(width),
height: u32::from(height),
width,
height,
present_mode: wgpu::PresentMode::Vsync,
},
)

6
wgpu/src/transformation.rs
View File

@ -13,10 +13,10 @@ impl Transformation {
/// Creates an orthographic projection.
#[rustfmt::skip]
pub fn orthographic(width: u16, height: u16) -> Transformation {
pub fn orthographic(width: u32, height: u32) -> Transformation {
Transformation(Mat4::from_cols(
Vec4::new(2.0 / f32::from(width), 0.0, 0.0, 0.0),
Vec4::new(0.0, 2.0 / f32::from(height), 0.0, 0.0),
Vec4::new(2.0 / width as f32, 0.0, 0.0, 0.0),
Vec4::new(0.0, 2.0 / height as f32, 0.0, 0.0),
Vec4::new(0.0, 0.0, -1.0, 0.0),
Vec4::new(-1.0, -1.0, 0.0, 1.0)
))

2
winit/Cargo.toml
View File

@ -14,7 +14,7 @@ categories = ["gui"]
debug = []
[dependencies]
winit = { version = "0.20.0-alpha3", git = "https://github.com/hecrj/winit", rev = "709808eb4e69044705fcb214bcc30556db761405"}
winit = "0.21"
log = "0.4"
[dependencies.iced_native]

69
winit/src/application.rs
View File

@ -138,10 +138,7 @@ pub trait Application: Sized {
window_builder = window_builder
.with_title(&title)
.with_inner_size(winit::dpi::LogicalSize {
width: f64::from(width),
height: f64::from(height),
})
.with_inner_size(winit::dpi::LogicalSize { width, height })
.with_resizable(settings.window.resizable)
.with_decorations(settings.window.decorations)
.with_fullscreen(conversion::fullscreen(
@ -161,18 +158,21 @@ pub trait Application: Sized {
window_builder.build(&event_loop).expect("Open window")
};
let dpi = window.hidpi_factor();
let mut size = window.inner_size();
let mut size = Size::new(window.inner_size(), window.scale_factor());
let mut resized = false;
let clipboard = Clipboard::new(&window);
let mut renderer = Self::Renderer::new(renderer_settings);
let mut target = {
let (width, height) = to_physical(size, dpi);
let physical_size = size.physical();
<Self::Renderer as window::Renderer>::Target::new(
&window, width, height, dpi as f32, &renderer,
&window,
physical_size.width,
physical_size.height,
size.scale_factor(),
&renderer,
)
};
@ -180,7 +180,7 @@ pub trait Application: Sized {
&mut application,
Cache::default(),
&mut renderer,
size,
size.logical(),
&mut debug,
);
@ -191,6 +191,7 @@ pub trait Application: Sized {
let mut cache = Some(user_interface.into_cache());
let mut events = Vec::new();
let mut mouse_cursor = MouseCursor::OutOfBounds;
let mut modifiers = winit::event::ModifiersState::default();
debug.startup_finished();
window.request_redraw();
@ -211,7 +212,7 @@ pub trait Application: Sized {
&mut application,
cache.take().unwrap(),
&mut renderer,
size,
size.logical(),
&mut debug,
);
@ -283,7 +284,7 @@ pub trait Application: Sized {
&mut application,
temp_cache,
&mut renderer,
size,
size.logical(),
&mut debug,
);
@ -303,13 +304,12 @@ pub trait Application: Sized {
debug.render_started();
if resized {
let dpi = window.hidpi_factor();
let (width, height) = to_physical(size, dpi);
let physical_size = size.physical();
target.resize(
width,
height,
window.hidpi_factor() as f32,
physical_size.width,
physical_size.height,
size.scale_factor(),
&renderer,
);
@ -337,18 +337,22 @@ pub trait Application: Sized {
..
} => match window_event {
WindowEvent::Resized(new_size) => {
size = Size::new(new_size, size.scale_factor());
events.push(Event::Window(window::Event::Resized {
width: new_size.width.round() as u32,
height: new_size.height.round() as u32,
width: size.logical().width.round() as u32,
height: size.logical().height.round() as u32,
}));
size = new_size;
resized = true;
}
WindowEvent::CloseRequested => {
*control_flow = ControlFlow::Exit;
}
WindowEvent::CursorMoved { position, .. } => {
let position =
position.to_logical::<f64>(size.scale_factor());
events.push(Event::Mouse(mouse::Event::CursorMoved {
x: position.x as f32,
y: position.y as f32,
@ -397,7 +401,6 @@ pub trait Application: Sized {
winit::event::KeyboardInput {
virtual_keycode: Some(virtual_keycode),
state,
modifiers,
..
},
..
@ -427,8 +430,17 @@ pub trait Application: Sized {
WindowEvent::HoveredFileCancelled => {
events.push(Event::Window(window::Event::FilesHoveredLeft));
}
WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
size = Size::new(size.physical(), scale_factor);
}
_ => {}
},
event::Event::DeviceEvent {
event: event::DeviceEvent::ModifiersChanged(new_modifiers),
..
} => {
modifiers = new_modifiers;
}
_ => {
*control_flow = ControlFlow::Wait;
}
@ -440,7 +452,7 @@ fn build_user_interface<'a, A: Application>(
application: &'a mut A,
cache: Cache,
renderer: &mut A::Renderer,
size: winit::dpi::LogicalSize,
size: winit::dpi::LogicalSize<f64>,
debug: &mut Debug,
) -> UserInterface<'a, A::Message, A::Renderer> {
debug.view_started();
@ -450,7 +462,10 @@ fn build_user_interface<'a, A: Application>(
debug.layout_started();
let user_interface = UserInterface::build(
view,
Size::new(size.width.round() as f32, size.height.round() as f32),
iced_native::Size::new(
size.width.round() as f32,
size.height.round() as f32,
),
cache,
renderer,
);
@ -459,17 +474,7 @@ fn build_user_interface<'a, A: Application>(
user_interface
}
fn to_physical(size: winit::dpi::LogicalSize, dpi: f64) -> (u16, u16) {
let physical_size = size.to_physical(dpi);
(
physical_size.width.round() as u16,
physical_size.height.round() as u16,
)
}
// As defined in: http://www.unicode.org/faq/private_use.html
// TODO: Remove once https://github.com/rust-windowing/winit/pull/1254 lands
fn is_private_use_character(c: char) -> bool {
match c {
'\u{E000}'..='\u{F8FF}'

8
winit/src/conversion.rs
View File

@ -74,10 +74,10 @@ pub fn modifiers_state(
modifiers: winit::event::ModifiersState,
) -> ModifiersState {
ModifiersState {
shift: modifiers.shift,
control: modifiers.ctrl,
alt: modifiers.alt,
logo: modifiers.logo,
shift: modifiers.shift(),
control: modifiers.ctrl(),
alt: modifiers.alt(),
logo: modifiers.logo(),
}
}

2
winit/src/lib.rs
View File

@ -32,6 +32,7 @@ mod application;
mod clipboard;
mod mode;
mod proxy;
mod size;
// We disable debug capabilities on release builds unless the `debug` feature
// is explicitly enabled.
@ -49,3 +50,4 @@ pub use settings::Settings;
use debug::Debug;
use proxy::Proxy;
use size::Size;

30
winit/src/size.rs Normal file
View File

@ -0,0 +1,30 @@
pub struct Size {
physical: winit::dpi::PhysicalSize<u32>,
logical: winit::dpi::LogicalSize<f64>,
scale_factor: f64,
}
impl Size {
pub fn new(
physical: winit::dpi::PhysicalSize<u32>,
scale_factor: f64,
) -> Size {
Size {
logical: physical.to_logical(scale_factor),
physical,
scale_factor,
}
}
pub fn physical(&self) -> winit::dpi::PhysicalSize<u32> {
self.physical
}
pub fn logical(&self) -> winit::dpi::LogicalSize<f64> {
self.logical
}
pub fn scale_factor(&self) -> f64 {
self.scale_factor
}
}