forestia/bevy
2
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Change Window scale factor to f32 (adopted) (#10897)

Browse Source 
# Objective

- Finish the work done in #8942 .

## Solution

- Rebase the changes made in #8942 and fix the issues stopping it from
being merged earlier

---------

Co-authored-by: Thomas <1234328+thmsgntz@users.noreply.github.com>
This commit is contained in:
Tygyh 2023-12-14 15:56:40 +01:00 committed by GitHub
parent 029dd06f7d
commit 720d6dab82
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 76 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
crates/bevy_render/src/camera/camera.rs
View File

@ -68,7 +68,7 @@ pub struct RenderTargetInfo {
/// The physical size of this render target (ignores scale factor). /// The physical size of this render target (ignores scale factor).
pub physical_size: UVec2, pub physical_size: UVec2,
/// The scale factor of this render target. /// The scale factor of this render target.
pub scale_factor: f64, pub scale_factor: f32,
} }
/// Holds internally computed [`Camera`] values. /// Holds internally computed [`Camera`] values.
@ -140,7 +140,7 @@ impl Camera {
#[inline] #[inline]
pub fn to_logical(&self, physical_size: UVec2) -> Option<Vec2> { pub fn to_logical(&self, physical_size: UVec2) -> Option<Vec2> {
let scale = self.computed.target_info.as_ref()?.scale_factor; let scale = self.computed.target_info.as_ref()?.scale_factor;
Some((physical_size.as_dvec2() / scale).as_vec2()) Some(physical_size.as_vec2() / scale)
} }
/// The rendered physical bounds [`URect`] of the camera. If the `viewport` field is /// The rendered physical bounds [`URect`] of the camera. If the `viewport` field is

4
crates/bevy_text/src/pipeline.rs
View File

@ -46,7 +46,7 @@ impl TextPipeline {
&mut self, &mut self,
fonts: &Assets<Font>, fonts: &Assets<Font>,
sections: &[TextSection], sections: &[TextSection],
scale_factor: f64, scale_factor: f32,
text_alignment: JustifyText, text_alignment: JustifyText,
linebreak_behavior: BreakLineOn, linebreak_behavior: BreakLineOn,
bounds: Vec2, bounds: Vec2,
@ -129,7 +129,7 @@ impl TextMeasureInfo {
pub fn from_text( pub fn from_text(
text: &Text, text: &Text,
fonts: &Assets<Font>, fonts: &Assets<Font>,
scale_factor: f64, scale_factor: f32,
) -> Result<TextMeasureInfo, TextError> { ) -> Result<TextMeasureInfo, TextError> {
let sections = &text.sections; let sections = &text.sections;
for section in sections { for section in sections {

6
crates/bevy_text/src/text2d.rs
View File

@ -99,7 +99,7 @@ pub fn extract_text2d_sprite(
// TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621 // TODO: Support window-independent scaling: https://github.com/bevyengine/bevy/issues/5621
let scale_factor = windows let scale_factor = windows
.get_single() .get_single()
.map(|window| window.resolution.scale_factor() as f32) .map(|window| window.resolution.scale_factor())
.unwrap_or(1.0); .unwrap_or(1.0);
let scaling = GlobalTransform::from_scale(Vec2::splat(scale_factor.recip()).extend(1.)); let scaling = GlobalTransform::from_scale(Vec2::splat(scale_factor.recip()).extend(1.));
@ -225,6 +225,6 @@ pub fn update_text2d_layout(
} }
/// Scales `value` by `factor`. /// Scales `value` by `factor`.
pub fn scale_value(value: f32, factor: f64) -> f32 { pub fn scale_value(value: f32, factor: f32) -> f32 {
(value as f64 * factor) as f32 value * factor
} }

2
crates/bevy_ui/src/focus.rs
View File

@ -181,7 +181,7 @@ pub fn ui_focus_system(
.or_else(|| touches_input.first_pressed_position()) .or_else(|| touches_input.first_pressed_position())
// The cursor position returned by `Window` only takes into account the window scale factor and not `UiScale`. // The cursor position returned by `Window` only takes into account the window scale factor and not `UiScale`.
// To convert the cursor position to logical UI viewport coordinates we have to divide it by `UiScale`. // To convert the cursor position to logical UI viewport coordinates we have to divide it by `UiScale`.
.map(|cursor_position| cursor_position / ui_scale.0 as f32); .map(|cursor_position| cursor_position / ui_scale.0);
// prepare an iterator that contains all the nodes that have the cursor in their rect, // prepare an iterator that contains all the nodes that have the cursor in their rect,
// from the top node to the bottom one. this will also reset the interaction to `None` // from the top node to the bottom one. this will also reset the interaction to `None`

6
crates/bevy_ui/src/layout/convert.rs
View File

@ -17,9 +17,9 @@ impl Val {
match self { match self {
Val::Auto => taffy::style::LengthPercentageAuto::Auto, Val::Auto => taffy::style::LengthPercentageAuto::Auto,
Val::Percent(value) => taffy::style::LengthPercentageAuto::Percent(value / 100.), Val::Percent(value) => taffy::style::LengthPercentageAuto::Percent(value / 100.),
Val::Px(value) => taffy::style::LengthPercentageAuto::Points( Val::Px(value) => {
(context.scale_factor * value as f64) as f32, taffy::style::LengthPercentageAuto::Points(context.scale_factor * value)
), }
Val::VMin(value) => { Val::VMin(value) => {
taffy::style::LengthPercentageAuto::Points(context.min_size * value / 100.) taffy::style::LengthPercentageAuto::Points(context.min_size * value / 100.)
} }

10
crates/bevy_ui/src/layout/mod.rs
View File

@ -22,7 +22,7 @@ use taffy::Taffy;
use thiserror::Error; use thiserror::Error;
pub struct LayoutContext { pub struct LayoutContext {
pub scale_factor: f64, pub scale_factor: f32,
pub physical_size: Vec2, pub physical_size: Vec2,
pub min_size: f32, pub min_size: f32,
pub max_size: f32, pub max_size: f32,
@ -30,7 +30,7 @@ pub struct LayoutContext {
impl LayoutContext { impl LayoutContext {
/// create new a [`LayoutContext`] from the window's physical size and scale factor /// create new a [`LayoutContext`] from the window's physical size and scale factor
fn new(scale_factor: f64, physical_size: Vec2) -> Self { fn new(scale_factor: f32, physical_size: Vec2) -> Self {
Self { Self {
scale_factor, scale_factor,
physical_size, physical_size,
@ -382,7 +382,7 @@ pub fn ui_layout_system(
&ui_surface, &ui_surface,
&mut node_transform_query, &mut node_transform_query,
&just_children_query, &just_children_query,
inverse_target_scale_factor as f32, inverse_target_scale_factor,
Vec2::ZERO, Vec2::ZERO,
Vec2::ZERO, Vec2::ZERO,
); );
@ -399,7 +399,7 @@ pub fn resolve_outlines_system(
.get_single() .get_single()
.map(|window| Vec2::new(window.resolution.width(), window.resolution.height())) .map(|window| Vec2::new(window.resolution.width(), window.resolution.height()))
.unwrap_or(Vec2::ZERO) .unwrap_or(Vec2::ZERO)
/ ui_scale.0 as f32; / ui_scale.0;
for (outline, mut node) in outlines_query.iter_mut() { for (outline, mut node) in outlines_query.iter_mut() {
let node = node.bypass_change_detection(); let node = node.bypass_change_detection();
@ -806,7 +806,7 @@ mod tests {
.copied() .copied()
.collect::<Vec<Entity>>(); .collect::<Vec<Entity>>();
for r in [2, 3, 5, 7, 11, 13, 17, 19, 21, 23, 29, 31].map(|n| (n as f64).recip()) { for r in [2, 3, 5, 7, 11, 13, 17, 19, 21, 23, 29, 31].map(|n| (n as f32).recip()) {
let mut s = r; let mut s = r;
while s <= 5. { while s <= 5. {
world.resource_mut::<UiScale>().0 = s; world.resource_mut::<UiScale>().0 = s;

2
crates/bevy_ui/src/lib.rs
View File

@ -76,7 +76,7 @@ pub enum UiSystem {
/// A multiplier to fixed-sized ui values. /// A multiplier to fixed-sized ui values.
/// **Note:** This will only affect fixed ui values like [`Val::Px`] /// **Note:** This will only affect fixed ui values like [`Val::Px`]
#[derive(Debug, Reflect, Resource, Deref, DerefMut)] #[derive(Debug, Reflect, Resource, Deref, DerefMut)]
pub struct UiScale(pub f64); pub struct UiScale(pub f32);
impl Default for UiScale { impl Default for UiScale {
fn default() -> Self { fn default() -> Self {

8
crates/bevy_ui/src/render/mod.rs
View File

@ -296,7 +296,7 @@ pub fn extract_uinode_borders(
.unwrap_or(Vec2::ZERO) .unwrap_or(Vec2::ZERO)
// The logical window resolution returned by `Window` only takes into account the window scale factor and not `UiScale`, // The logical window resolution returned by `Window` only takes into account the window scale factor and not `UiScale`,
// so we have to divide by `UiScale` to get the size of the UI viewport. // so we have to divide by `UiScale` to get the size of the UI viewport.
/ ui_scale.0 as f32; / ui_scale.0;
for (node, global_transform, style, border_color, parent, view_visibility, clip) in for (node, global_transform, style, border_color, parent, view_visibility, clip) in
uinode_query.iter() uinode_query.iter()
@ -540,7 +540,7 @@ pub fn extract_default_ui_camera_view<T: Component>(
ui_scale: Extract<Res<UiScale>>, ui_scale: Extract<Res<UiScale>>,
query: Extract<Query<(Entity, &Camera, Option<&UiCameraConfig>), With<T>>>, query: Extract<Query<(Entity, &Camera, Option<&UiCameraConfig>), With<T>>>,
) { ) {
let scale = (ui_scale.0 as f32).recip(); let scale = (ui_scale.0).recip();
for (entity, camera, camera_ui) in &query { for (entity, camera, camera_ui) in &query {
// ignore cameras with disabled ui // ignore cameras with disabled ui
if matches!(camera_ui, Some(&UiCameraConfig { show_ui: false, .. })) { if matches!(camera_ui, Some(&UiCameraConfig { show_ui: false, .. })) {
@ -619,11 +619,11 @@ pub fn extract_text_uinodes(
) { ) {
// TODO: Support window-independent UI scale: https://github.com/bevyengine/bevy/issues/5621 // TODO: Support window-independent UI scale: https://github.com/bevyengine/bevy/issues/5621
let scale_factor = (windows let scale_factor = windows
.get_single() .get_single()
.map(|window| window.scale_factor()) .map(|window| window.scale_factor())
.unwrap_or(1.) .unwrap_or(1.)
* ui_scale.0) as f32; * ui_scale.0;
let inverse_scale_factor = scale_factor.recip(); let inverse_scale_factor = scale_factor.recip();

2
crates/bevy_ui/src/render/ui_material_pipeline.rs
View File

@ -374,7 +374,7 @@ pub fn extract_ui_material_nodes<M: UiMaterial>(
.unwrap_or(Vec2::ZERO) .unwrap_or(Vec2::ZERO)
// The logical window resolution returned by `Window` only takes into account the window scale factor and not `UiScale`, // The logical window resolution returned by `Window` only takes into account the window scale factor and not `UiScale`,
// so we have to divide by `UiScale` to get the size of the UI viewport. // so we have to divide by `UiScale` to get the size of the UI viewport.
/ ui_scale.0 as f32; / ui_scale.0;
for (stack_index, entity) in ui_stack.uinodes.iter().enumerate() { for (stack_index, entity) in ui_stack.uinodes.iter().enumerate() {
if let Ok((entity, uinode, style, transform, handle, view_visibility, clip)) = if let Ok((entity, uinode, style, transform, handle, view_visibility, clip)) =
uinode_query.get(*entity) uinode_query.get(*entity)

18
crates/bevy_ui/src/ui_node.rs
View File

@ -57,10 +57,10 @@ impl Node {
/// Returns the size of the node in physical pixels based on the given scale factor and `UiScale`. /// Returns the size of the node in physical pixels based on the given scale factor and `UiScale`.
#[inline] #[inline]
pub fn physical_size(&self, scale_factor: f64, ui_scale: f64) -> Vec2 { pub fn physical_size(&self, scale_factor: f32, ui_scale: f32) -> Vec2 {
Vec2::new( Vec2::new(
(self.calculated_size.x as f64 * scale_factor * ui_scale) as f32, self.calculated_size.x * scale_factor * ui_scale,
(self.calculated_size.y as f64 * scale_factor * ui_scale) as f32, self.calculated_size.y * scale_factor * ui_scale,
) )
} }
@ -75,18 +75,18 @@ impl Node {
pub fn physical_rect( pub fn physical_rect(
&self, &self,
transform: &GlobalTransform, transform: &GlobalTransform,
scale_factor: f64, scale_factor: f32,
ui_scale: f64, ui_scale: f32,
) -> Rect { ) -> Rect {
let rect = self.logical_rect(transform); let rect = self.logical_rect(transform);
Rect { Rect {
min: Vec2::new( min: Vec2::new(
(rect.min.x as f64 * scale_factor * ui_scale) as f32, rect.min.x * scale_factor * ui_scale,
(rect.min.y as f64 * scale_factor * ui_scale) as f32, rect.min.y * scale_factor * ui_scale,
), ),
max: Vec2::new( max: Vec2::new(
(rect.max.x as f64 * scale_factor * ui_scale) as f32, rect.max.x * scale_factor * ui_scale,
(rect.max.y as f64 * scale_factor * ui_scale) as f32, rect.max.y * scale_factor * ui_scale,
), ),
} }
} }

8
crates/bevy_ui/src/widget/image.rs
View File

@ -78,7 +78,7 @@ type UpdateImageFilter = With<Node>;
/// Updates content size of the node based on the image provided /// Updates content size of the node based on the image provided
pub fn update_image_content_size_system( pub fn update_image_content_size_system(
mut previous_combined_scale_factor: Local<f64>, mut previous_combined_scale_factor: Local<f32>,
windows: Query<&Window, With<PrimaryWindow>>, windows: Query<&Window, With<PrimaryWindow>>,
ui_scale: Res<UiScale>, ui_scale: Res<UiScale>,
textures: Res<Assets<Image>>, textures: Res<Assets<Image>>,
@ -101,7 +101,7 @@ pub fn update_image_content_size_system(
image_size.size = size; image_size.size = size;
content_size.set(ImageMeasure { content_size.set(ImageMeasure {
// multiply the image size by the scale factor to get the physical size // multiply the image size by the scale factor to get the physical size
size: size * combined_scale_factor as f32, size: size * combined_scale_factor,
}); });
} }
} }
@ -112,7 +112,7 @@ pub fn update_image_content_size_system(
/// Updates content size of the node based on the texture atlas sprite /// Updates content size of the node based on the texture atlas sprite
pub fn update_atlas_content_size_system( pub fn update_atlas_content_size_system(
mut previous_combined_scale_factor: Local<f64>, mut previous_combined_scale_factor: Local<f32>,
windows: Query<&Window, With<PrimaryWindow>>, windows: Query<&Window, With<PrimaryWindow>>,
ui_scale: Res<UiScale>, ui_scale: Res<UiScale>,
atlases: Res<Assets<TextureAtlas>>, atlases: Res<Assets<TextureAtlas>>,
@ -143,7 +143,7 @@ pub fn update_atlas_content_size_system(
image_size.size = size; image_size.size = size;
content_size.set(ImageMeasure { content_size.set(ImageMeasure {
// multiply the image size by the scale factor to get the physical size // multiply the image size by the scale factor to get the physical size
size: size * combined_scale_factor as f32, size: size * combined_scale_factor,
}); });
} }
} }

14
crates/bevy_ui/src/widget/text.rs
View File

@ -80,7 +80,7 @@ impl Measure for TextMeasure {
#[inline] #[inline]
fn create_text_measure( fn create_text_measure(
fonts: &Assets<Font>, fonts: &Assets<Font>,
scale_factor: f64, scale_factor: f32,
text: Ref<Text>, text: Ref<Text>,
mut content_size: Mut<ContentSize>, mut content_size: Mut<ContentSize>,
mut text_flags: Mut<TextFlags>, mut text_flags: Mut<TextFlags>,
@ -117,7 +117,7 @@ fn create_text_measure(
/// color changes. This can be expensive, particularly for large blocks of text, and the [`bypass_change_detection`](bevy_ecs::change_detection::DetectChangesMut::bypass_change_detection) /// color changes. This can be expensive, particularly for large blocks of text, and the [`bypass_change_detection`](bevy_ecs::change_detection::DetectChangesMut::bypass_change_detection)
/// method should be called when only changing the `Text`'s colors. /// method should be called when only changing the `Text`'s colors.
pub fn measure_text_system( pub fn measure_text_system(
mut last_scale_factor: Local<f64>, mut last_scale_factor: Local<f32>,
fonts: Res<Assets<Font>>, fonts: Res<Assets<Font>>,
windows: Query<&Window, With<PrimaryWindow>>, windows: Query<&Window, With<PrimaryWindow>>,
ui_scale: Res<UiScale>, ui_scale: Res<UiScale>,
@ -158,8 +158,8 @@ fn queue_text(
texture_atlases: &mut Assets<TextureAtlas>, texture_atlases: &mut Assets<TextureAtlas>,
textures: &mut Assets<Image>, textures: &mut Assets<Image>,
text_settings: &TextSettings, text_settings: &TextSettings,
scale_factor: f64, scale_factor: f32,
inverse_scale_factor: f64, inverse_scale_factor: f32,
text: &Text, text: &Text,
node: Ref<Node>, node: Ref<Node>,
mut text_flags: Mut<TextFlags>, mut text_flags: Mut<TextFlags>,
@ -173,8 +173,8 @@ fn queue_text(
} else { } else {
// `scale_factor` is already multiplied by `UiScale` // `scale_factor` is already multiplied by `UiScale`
Vec2::new( Vec2::new(
(node.unrounded_size.x as f64 * scale_factor) as f32, node.unrounded_size.x * scale_factor,
(node.unrounded_size.y as f64 * scale_factor) as f32, node.unrounded_size.y * scale_factor,
) )
}; };
@ -220,7 +220,7 @@ fn queue_text(
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
pub fn text_system( pub fn text_system(
mut textures: ResMut<Assets<Image>>, mut textures: ResMut<Assets<Image>>,
mut last_scale_factor: Local<f64>, mut last_scale_factor: Local<f32>,
fonts: Res<Assets<Font>>, fonts: Res<Assets<Font>>,
windows: Query<&Window, With<PrimaryWindow>>, windows: Query<&Window, With<PrimaryWindow>>,
text_settings: Res<TextSettings>, text_settings: Res<TextSettings>,

30
crates/bevy_window/src/window.rs
View File

@ -326,7 +326,7 @@ impl Window {
/// ///
/// Ratio of physical size to logical size, see [`WindowResolution`]. /// Ratio of physical size to logical size, see [`WindowResolution`].
#[inline] #[inline]
pub fn scale_factor(&self) -> f64 { pub fn scale_factor(&self) -> f32 {
self.resolution.scale_factor() self.resolution.scale_factor()
} }
@ -338,7 +338,7 @@ impl Window {
#[inline] #[inline]
pub fn cursor_position(&self) -> Option<Vec2> { pub fn cursor_position(&self) -> Option<Vec2> {
self.physical_cursor_position() self.physical_cursor_position()
.map(|position| (position.as_dvec2() / self.scale_factor()).as_vec2()) .map(|position| (position.as_dvec2() / self.scale_factor() as f64).as_vec2())
} }
/// The cursor position in this window in physical pixels. /// The cursor position in this window in physical pixels.
@ -369,7 +369,7 @@ impl Window {
/// See [`WindowResolution`] for an explanation about logical/physical sizes. /// See [`WindowResolution`] for an explanation about logical/physical sizes.
pub fn set_cursor_position(&mut self, position: Option<Vec2>) { pub fn set_cursor_position(&mut self, position: Option<Vec2>) {
self.internal.physical_cursor_position = self.internal.physical_cursor_position =
position.map(|p| p.as_dvec2() * self.scale_factor()); position.map(|p| p.as_dvec2() * self.scale_factor() as f64);
} }
/// Set the cursor position in this window in physical pixels. /// Set the cursor position in this window in physical pixels.
@ -611,11 +611,11 @@ pub struct WindowResolution {
/// Code-provided ratio of physical size to logical size. /// Code-provided ratio of physical size to logical size.
/// ///
/// Should be used instead of `scale_factor` when set. /// Should be used instead of `scale_factor` when set.
scale_factor_override: Option<f64>, scale_factor_override: Option<f32>,
/// OS-provided ratio of physical size to logical size. /// OS-provided ratio of physical size to logical size.
/// ///
/// Set automatically depending on the pixel density of the screen. /// Set automatically depending on the pixel density of the screen.
scale_factor: f64, scale_factor: f32,
} }
impl Default for WindowResolution { impl Default for WindowResolution {
@ -640,7 +640,7 @@ impl WindowResolution {
} }
/// Builder method for adding a scale factor override to the resolution. /// Builder method for adding a scale factor override to the resolution.
pub fn with_scale_factor_override(mut self, scale_factor_override: f64) -> Self { pub fn with_scale_factor_override(mut self, scale_factor_override: f32) -> Self {
self.scale_factor_override = Some(scale_factor_override); self.scale_factor_override = Some(scale_factor_override);
self self
} }
@ -648,13 +648,13 @@ impl WindowResolution {
/// The window's client area width in logical pixels. /// The window's client area width in logical pixels.
#[inline] #[inline]
pub fn width(&self) -> f32 { pub fn width(&self) -> f32 {
(self.physical_width() as f64 / self.scale_factor()) as f32 self.physical_width() as f32 / self.scale_factor()
} }
/// The window's client area height in logical pixels. /// The window's client area height in logical pixels.
#[inline] #[inline]
pub fn height(&self) -> f32 { pub fn height(&self) -> f32 {
(self.physical_height() as f64 / self.scale_factor()) as f32 self.physical_height() as f32 / self.scale_factor()
} }
/// The window's client area width in physical pixels. /// The window's client area width in physical pixels.
@ -672,7 +672,7 @@ impl WindowResolution {
/// The ratio of physical pixels to logical pixels. /// The ratio of physical pixels to logical pixels.
/// ///
/// `physical_pixels = logical_pixels * scale_factor` /// `physical_pixels = logical_pixels * scale_factor`
pub fn scale_factor(&self) -> f64 { pub fn scale_factor(&self) -> f32 {
self.scale_factor_override self.scale_factor_override
.unwrap_or_else(|| self.base_scale_factor()) .unwrap_or_else(|| self.base_scale_factor())
} }
@ -681,7 +681,7 @@ impl WindowResolution {
/// ///
/// This value is unaffected by [`WindowResolution::scale_factor_override`]. /// This value is unaffected by [`WindowResolution::scale_factor_override`].
#[inline] #[inline]
pub fn base_scale_factor(&self) -> f64 { pub fn base_scale_factor(&self) -> f32 {
self.scale_factor self.scale_factor
} }
@ -689,7 +689,7 @@ impl WindowResolution {
/// ///
/// This value may be different from the scale factor reported by the window backend. /// This value may be different from the scale factor reported by the window backend.
#[inline] #[inline]
pub fn scale_factor_override(&self) -> Option<f64> { pub fn scale_factor_override(&self) -> Option<f32> {
self.scale_factor_override self.scale_factor_override
} }
@ -697,8 +697,8 @@ impl WindowResolution {
#[inline] #[inline]
pub fn set(&mut self, width: f32, height: f32) { pub fn set(&mut self, width: f32, height: f32) {
self.set_physical_resolution( self.set_physical_resolution(
(width as f64 * self.scale_factor()) as u32, (width * self.scale_factor()) as u32,
(height as f64 * self.scale_factor()) as u32, (height * self.scale_factor()) as u32,
); );
} }
@ -714,7 +714,7 @@ impl WindowResolution {
/// Set the window's scale factor, this may get overridden by the backend. /// Set the window's scale factor, this may get overridden by the backend.
#[inline] #[inline]
pub fn set_scale_factor(&mut self, scale_factor: f64) { pub fn set_scale_factor(&mut self, scale_factor: f32) {
let (width, height) = (self.width(), self.height()); let (width, height) = (self.width(), self.height());
self.scale_factor = scale_factor; self.scale_factor = scale_factor;
self.set(width, height); self.set(width, height);
@ -725,7 +725,7 @@ impl WindowResolution {
/// This can change the logical and physical sizes if the resulting physical /// This can change the logical and physical sizes if the resulting physical
/// size is not within the limits. /// size is not within the limits.
#[inline] #[inline]
pub fn set_scale_factor_override(&mut self, scale_factor_override: Option<f64>) { pub fn set_scale_factor_override(&mut self, scale_factor_override: Option<f32>) {
let (width, height) = (self.width(), self.height()); let (width, height) = (self.width(), self.height());
self.scale_factor_override = scale_factor_override; self.scale_factor_override = scale_factor_override;
self.set(width, height); self.set(width, height);

14
crates/bevy_winit/src/lib.rs
View File

@ -545,7 +545,7 @@ pub fn winit_runner(mut app: App) {
window.set_physical_cursor_position(Some(physical_position)); window.set_physical_cursor_position(Some(physical_position));
event_writers.cursor_moved.send(CursorMoved { event_writers.cursor_moved.send(CursorMoved {
window: window_entity, window: window_entity,
position: (physical_position / window.resolution.scale_factor()) position: (physical_position / window.resolution.scale_factor() as f64)
.as_vec2(), .as_vec2(),
}); });
} }
@ -596,7 +596,9 @@ pub fn winit_runner(mut app: App) {
} }
}, },
WindowEvent::Touch(touch) => { WindowEvent::Touch(touch) => {
let location = touch.location.to_logical(window.resolution.scale_factor()); let location = touch
.location
.to_logical(window.resolution.scale_factor() as f64);
event_writers event_writers
.touch_input .touch_input
.send(converters::convert_touch_input(touch, location)); .send(converters::convert_touch_input(touch, location));
@ -619,7 +621,7 @@ pub fn winit_runner(mut app: App) {
); );
let prior_factor = window.resolution.scale_factor(); let prior_factor = window.resolution.scale_factor();
window.resolution.set_scale_factor(scale_factor); window.resolution.set_scale_factor(scale_factor as f32);
let new_factor = window.resolution.scale_factor(); let new_factor = window.resolution.scale_factor();
if let Some(forced_factor) = window.resolution.scale_factor_override() { if let Some(forced_factor) = window.resolution.scale_factor_override() {
@ -628,7 +630,7 @@ pub fn winit_runner(mut app: App) {
// incorporates any resize constraints. // incorporates any resize constraints.
*new_inner_size = *new_inner_size =
winit::dpi::LogicalSize::new(window.width(), window.height()) winit::dpi::LogicalSize::new(window.width(), window.height())
.to_physical::<u32>(forced_factor); .to_physical::<u32>(forced_factor as f64);
} else if approx::relative_ne!(new_factor, prior_factor) { } else if approx::relative_ne!(new_factor, prior_factor) {
event_writers.window_scale_factor_changed.send( event_writers.window_scale_factor_changed.send(
WindowScaleFactorChanged { WindowScaleFactorChanged {
@ -638,8 +640,8 @@ pub fn winit_runner(mut app: App) {
); );
} }
let new_logical_width = (new_inner_size.width as f64 / new_factor) as f32; let new_logical_width = new_inner_size.width as f32 / new_factor;
let new_logical_height = (new_inner_size.height as f64 / new_factor) as f32; let new_logical_height = new_inner_size.height as f32 / new_factor;
if approx::relative_ne!(window.width(), new_logical_width) if approx::relative_ne!(window.width(), new_logical_width)
|| approx::relative_ne!(window.height(), new_logical_height) || approx::relative_ne!(window.height(), new_logical_height)
{ {

2
crates/bevy_winit/src/system.rs
View File

@ -73,7 +73,7 @@ pub(crate) fn create_windows<'a>(
window window
.resolution .resolution
.set_scale_factor(winit_window.scale_factor()); .set_scale_factor(winit_window.scale_factor() as f32);
commands commands
.entity(entity) .entity(entity)
.insert(RawHandleWrapper { .insert(RawHandleWrapper {

2
crates/bevy_winit/src/winit_windows.rs
View File

@ -82,7 +82,7 @@ impl WinitWindows {
let logical_size = LogicalSize::new(window.width(), window.height()); let logical_size = LogicalSize::new(window.width(), window.height());
if let Some(sf) = window.resolution.scale_factor_override() { if let Some(sf) = window.resolution.scale_factor_override() {
winit_window_builder.with_inner_size(logical_size.to_physical::<f64>(sf)) winit_window_builder.with_inner_size(logical_size.to_physical::<f64>(sf.into()))
} else { } else {
winit_window_builder.with_inner_size(logical_size) winit_window_builder.with_inner_size(logical_size)
} }

4
examples/ui/text_wrap_debug.rs
View File

@ -11,11 +11,11 @@ use bevy::winit::WinitSettings;
struct Args { struct Args {
#[argh(option)] #[argh(option)]
/// window scale factor /// window scale factor
scale_factor: Option<f64>, scale_factor: Option<f32>,
#[argh(option, default = "1.")] #[argh(option, default = "1.")]
/// ui scale factor /// ui scale factor
ui_scale: f64, ui_scale: f32,
} }
fn main() { fn main() {

14
examples/ui/ui_scaling.rs
View File

@ -99,21 +99,21 @@ fn change_scaling(input: Res<ButtonInput<KeyCode>>, mut ui_scale: ResMut<TargetS
#[derive(Resource)] #[derive(Resource)]
struct TargetScale { struct TargetScale {
start_scale: f64, start_scale: f32,
target_scale: f64, target_scale: f32,
target_time: Timer, target_time: Timer,
} }
impl TargetScale { impl TargetScale {
fn set_scale(&mut self, scale: f64) { fn set_scale(&mut self, scale: f32) {
self.start_scale = self.current_scale(); self.start_scale = self.current_scale();
self.target_scale = scale; self.target_scale = scale;
self.target_time.reset(); self.target_time.reset();
} }
fn current_scale(&self) -> f64 { fn current_scale(&self) -> f32 {
let completion = self.target_time.fraction(); let completion = self.target_time.fraction();
let multiplier = ease_in_expo(completion as f64); let multiplier = ease_in_expo(completion);
self.start_scale + (self.target_scale - self.start_scale) * multiplier self.start_scale + (self.target_scale - self.start_scale) * multiplier
} }
@ -139,10 +139,10 @@ fn apply_scaling(
ui_scale.0 = target_scale.current_scale(); ui_scale.0 = target_scale.current_scale();
} }
fn ease_in_expo(x: f64) -> f64 { fn ease_in_expo(x: f32) -> f32 {
if x == 0. { if x == 0. {
0. 0.
} else { } else {
(2.0f64).powf(5. * x - 5.) 2.0f32.powf(5. * x - 5.)
} }
} }