Struct bevy_window::WindowResolution

pub struct WindowResolution { /* private fields */ }

Controls the size of a Window

Physical, logical and requested sizes

There are three sizes associated with a window:

• the physical size, which represents the actual height and width in physical pixels the window occupies on the monitor,
• the logical size, which represents the size that should be used to scale elements inside the window, measured in logical pixels,
• the requested size, measured in logical pixels, which is the value submitted to the API when creating the window, or requesting that it be resized.

Scale factor

The reason logical size and physical size are separated and can be different is to account for the cases where:

• several monitors have different pixel densities,
• the user has set up a pixel density preference in its operating system,
• the Bevy App has specified a specific scale factor between both.

The factor between physical size and logical size can be retrieved with WindowResolution::scale_factor.

For the first two cases, a scale factor is set automatically by the operating system through the window backend. You can get it with WindowResolution::base_scale_factor.

For the third case, you can override this automatic scale factor with WindowResolution::set_scale_factor_override.

Requested and obtained sizes

The logical size should be equal to the requested size after creating/resizing, when possible. The reason the requested size and logical size might be different is because the corresponding physical size might exceed limits (either the size limits of the monitor, or limits defined in WindowResizeConstraints).

Note: The requested size is not kept in memory, for example requesting a size too big for the screen, making the logical size different from the requested size, and then setting a scale factor that makes the previous requested size within the limits of the screen will not get back that previous requested size.

Implementations

impl WindowResolution

pub fn new(logical_width: f32, logical_height: f32) -> Self

Creates a new WindowResolution.

pub fn with_scale_factor_override(self, scale_factor_override: f32) -> Self

Builder method for adding a scale factor override to the resolution.

pub fn width(&self) -> f32

The window’s client area width in logical pixels.

pub fn height(&self) -> f32

The window’s client area height in logical pixels.

pub fn physical_width(&self) -> u32

The window’s client area width in physical pixels.

pub fn physical_height(&self) -> u32

The window’s client area height in physical pixels.

pub fn scale_factor(&self) -> f32

The ratio of physical pixels to logical pixels.

physical_pixels = logical_pixels * scale_factor

pub fn base_scale_factor(&self) -> f32

The window scale factor as reported by the window backend.

This value is unaffected by WindowResolution::scale_factor_override.

pub fn scale_factor_override(&self) -> Option<f32>

The scale factor set with WindowResolution::set_scale_factor_override.

This value may be different from the scale factor reported by the window backend.

pub fn set(&mut self, width: f32, height: f32)

Set the window’s logical resolution.

pub fn set_physical_resolution(&mut self, width: u32, height: u32)

Set the window’s physical resolution.

This will ignore the scale factor setting, so most of the time you should prefer to use WindowResolution::set.

pub fn set_scale_factor(&mut self, scale_factor: f32)

Set the window’s scale factor, this may get overridden by the backend.

pub fn set_scale_factor_override(&mut self, scale_factor_override: Option<f32>)

Set the window’s scale factor, this will be used over what the backend decides.

This can change the logical and physical sizes if the resulting physical size is not within the limits.

Trait Implementations

impl Clone for WindowResolution

fn clone(&self) -> WindowResolution

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WindowResolution

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for WindowResolution

fn default() -> Self

Returns the “default value” for a type.

impl<I> From<[I; 2]> for WindowResolution

where I: Into<f32>,

fn from([width, height]: [I; 2]) -> WindowResolution

Converts to this type from the input type.

impl<I> From<(I, I)> for WindowResolution

where I: Into<f32>,

fn from((width, height): (I, I)) -> WindowResolution

Converts to this type from the input type.

impl From<DVec2> for WindowResolution

fn from(res: DVec2) -> WindowResolution

Converts to this type from the input type.

impl From<Vec2> for WindowResolution

fn from(res: Vec2) -> WindowResolution

Converts to this type from the input type.

impl FromReflect for WindowResolution

where Self: Any + Send + Sync, u32: FromReflect + TypePath, Option<f32>: FromReflect + TypePath, f32: FromReflect + TypePath,

fn from_reflect(reflect: &dyn Reflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn Reflect> ) -> Result<Self, Box<dyn Reflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for WindowResolution

where Self: Any + Send + Sync, u32: FromReflect + TypePath, Option<f32>: FromReflect + TypePath, f32: FromReflect + TypePath,

fn get_type_registration() -> TypeRegistration

impl PartialEq for WindowResolution

fn eq(&self, other: &WindowResolution) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Reflect for WindowResolution

where Self: Any + Send + Sync, u32: FromReflect + TypePath, Option<f32>: FromReflect + TypePath, f32: FromReflect + TypePath,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable reflected value.

fn clone_value(&self) -> Box<dyn Reflect>

Clones the value as a Reflect trait object.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

fn apply(&mut self, value: &dyn Reflect)

Applies a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool>

Returns a “partial equality” comparison result.

fn debug(&self, f: &mut Formatter<'_>) -> Result

Debug formatter for the value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Struct for WindowResolution

where Self: Any + Send + Sync, u32: FromReflect + TypePath, Option<f32>: FromReflect + TypePath, f32: FromReflect + TypePath,

fn field(&self, name: &str) -> Option<&dyn Reflect>

Returns a reference to the value of the field named name as a &dyn Reflect.

fn field_mut(&mut self, name: &str) -> Option<&mut dyn Reflect>

Returns a mutable reference to the value of the field named name as a &mut dyn Reflect.

fn field_at(&self, index: usize) -> Option<&dyn Reflect>

Returns a reference to the value of the field with index index as a &dyn Reflect.

fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect>

Returns a mutable reference to the value of the field with index index as a &mut dyn Reflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

impl TypePath for WindowResolution

where Self: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for WindowResolution

where Self: Any + Send + Sync, u32: FromReflect + TypePath, Option<f32>: FromReflect + TypePath, f32: FromReflect + TypePath,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl StructuralPartialEq for WindowResolution