Enum UpdateMode

pub enum UpdateMode {
    Continuous,
    Reactive {
        wait: Duration,
        react_to_device_events: bool,
        react_to_user_events: bool,
        react_to_window_events: bool,
    },
}

Determines how frequently an App should update.

Note: This setting is independent of VSync. VSync is controlled by a window’s PresentMode setting. If an app can update faster than the refresh rate, but VSync is enabled, the update rate will be indirectly limited by the renderer.

Variants

Continuous

The App will update over and over, as fast as it possibly can, until an AppExit event appears.

Reactive

The App will update in response to the following, until an AppExit event appears:

• wait time has elapsed since the previous update
• a redraw has been requested by RequestRedraw
• new window, raw input, or custom events have appeared
• a redraw has been requested with the EventLoopProxy

Fields

wait: Duration

The approximate time from the start of one update to the next.

Note: This has no upper limit. The App will wait indefinitely if you set this to Duration::MAX.

react_to_device_events: bool

Reacts to device events, that will wake up the loop if it’s in a wait state

react_to_user_events: bool

Reacts to user events, that will wake up the loop if it’s in a wait state

react_to_window_events: bool

Reacts to window events, that will wake up the loop if it’s in a wait state

Implementations

impl UpdateMode

pub fn reactive(wait: Duration) -> UpdateMode

Reactive mode, will update the app for any kind of event

pub fn reactive_low_power(wait: Duration) -> UpdateMode

Low power mode

Unlike Reactive, this will ignore events that don’t come from interacting with a window, like MouseMotion. Use this if, for example, you only want your app to update when the mouse cursor is moving over a window, not just moving in general. This can greatly reduce power consumption.

Examples found in repository

examples/window/low_power.rs (line 22)

fn main() {
    App::new()
        // Continuous rendering for games - bevy's default.
        .insert_resource(WinitSettings::game())
        // Power-saving reactive rendering for applications.
        .insert_resource(WinitSettings::desktop_app())
        // You can also customize update behavior with the fields of [`WinitSettings`]
        .insert_resource(WinitSettings {
            focused_mode: bevy::winit::UpdateMode::Continuous,
            unfocused_mode: bevy::winit::UpdateMode::reactive_low_power(Duration::from_millis(10)),
        })
        .insert_resource(ExampleMode::Game)
        .add_plugins(DefaultPlugins.set(WindowPlugin {
            primary_window: Some(Window {
                // Turn off vsync to maximize CPU/GPU usage
                present_mode: PresentMode::AutoNoVsync,
                ..default()
            }),
            ..default()
        }))
        .add_systems(Startup, test_setup::setup)
        .add_systems(
            Update,
            (
                test_setup::cycle_modes,
                test_setup::rotate_cube,
                test_setup::update_text,
                update_winit,
            ),
        )
        .run();
}

Trait Implementations

impl Clone for UpdateMode

fn clone(&self) -> UpdateMode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for UpdateMode

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

Formats the value using the given formatter.

impl PartialEq for UpdateMode

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for UpdateMode

impl StructuralPartialEq for UpdateMode