Struct Timer

Source
pub struct Timer { /* private fields */ }
Expand description

Tracks elapsed time. Enters the finished state once duration is reached.

Non repeating timers will stop tracking and stay in the finished state until reset. Repeating timers will only be in the finished state on each tick duration is reached or exceeded, and can still be reset at any given point.

Paused timers will not have elapsed time increased.

Note that in order to advance the timer tick MUST be called.

Implementations§

Source§

impl Timer

Source

pub fn new(duration: Duration, mode: TimerMode) -> Timer

Creates a new timer with a given duration.

See also Timer::from_seconds.

Examples found in repository?
examples/2d/sprite_animation.rs (line 51)
50    fn timer_from_fps(fps: u8) -> Timer {
51        Timer::new(Duration::from_secs_f32(1.0 / (fps as f32)), TimerMode::Once)
52    }
More examples
Hide additional examples
examples/window/custom_cursor_image.rs (line 108)
107    fn timer_from_fps(fps: u8) -> Timer {
108        Timer::new(Duration::from_secs_f32(1.0 / (fps as f32)), TimerMode::Once)
109    }
examples/app/plugin.rs (line 35)
32    fn build(&self, app: &mut App) {
33        let state = PrintMessageState {
34            message: self.message.clone(),
35            timer: Timer::new(self.wait_duration, TimerMode::Repeating),
36        };
37        app.insert_resource(state)
38            .add_systems(Update, print_message_system);
39    }
examples/ui/ui_scaling.rs (line 14)
8fn main() {
9    App::new()
10        .add_plugins(DefaultPlugins)
11        .insert_resource(TargetScale {
12            start_scale: 1.0,
13            target_scale: 1.0,
14            target_time: Timer::new(Duration::from_millis(SCALE_TIME), TimerMode::Once),
15        })
16        .add_systems(Startup, setup)
17        .add_systems(
18            Update,
19            (change_scaling, apply_scaling.after(change_scaling)),
20        )
21        .run();
22}
Source

pub fn from_seconds(duration: f32, mode: TimerMode) -> Timer

Creates a new timer with a given duration in seconds.

§Example
let mut timer = Timer::from_seconds(1.0, TimerMode::Once);
Examples found in repository?
examples/stress_tests/many_cubes.rs (line 482)
481    fn default() -> Self {
482        Self(Timer::from_seconds(1.0, TimerMode::Repeating))
483    }
More examples
Hide additional examples
examples/stress_tests/many_lights.rs (line 187)
186    fn default() -> Self {
187        Self(Timer::from_seconds(1.0, TimerMode::Repeating))
188    }
examples/stress_tests/many_sprites.rs (line 118)
117    fn default() -> Self {
118        Self(Timer::from_seconds(1.0, TimerMode::Repeating))
119    }
examples/stress_tests/many_text2d.rs (line 100)
99    fn default() -> Self {
100        Self(Timer::from_seconds(1.0, TimerMode::Repeating))
101    }
examples/ecs/event.rs (line 29)
28    fn default() -> Self {
29        DamageTimer(Timer::from_seconds(1.0, TimerMode::Repeating))
30    }
examples/games/contributors.rs (lines 38-41)
37    fn default() -> Self {
38        Self(Timer::from_seconds(
39            SHOWCASE_TIMER_SECS,
40            TimerMode::Repeating,
41        ))
42    }
Source

pub fn finished(&self) -> bool

Returns true if the timer has reached its duration.

For repeating timers, this method behaves identically to Timer::just_finished.

§Examples
use std::time::Duration;

let mut timer_once = Timer::from_seconds(1.0, TimerMode::Once);
timer_once.tick(Duration::from_secs_f32(1.5));
assert!(timer_once.finished());
timer_once.tick(Duration::from_secs_f32(0.5));
assert!(timer_once.finished());

let mut timer_repeating = Timer::from_seconds(1.0, TimerMode::Repeating);
timer_repeating.tick(Duration::from_secs_f32(1.1));
assert!(timer_repeating.finished());
timer_repeating.tick(Duration::from_secs_f32(0.8));
assert!(!timer_repeating.finished());
timer_repeating.tick(Duration::from_secs_f32(0.6));
assert!(timer_repeating.finished());
Examples found in repository?
examples/ui/ui_scaling.rs (line 118)
117    fn already_completed(&self) -> bool {
118        self.target_time.finished() && !self.target_time.just_finished()
119    }
More examples
Hide additional examples
examples/app/plugin.rs (line 49)
48fn print_message_system(mut state: ResMut<PrintMessageState>, time: Res<Time>) {
49    if state.timer.tick(time.delta()).finished() {
50        info!("{}", state.message);
51    }
52}
examples/games/game_menu.rs (line 104)
99    fn countdown(
100        mut game_state: ResMut<NextState<GameState>>,
101        time: Res<Time>,
102        mut timer: ResMut<SplashTimer>,
103    ) {
104        if timer.tick(time.delta()).finished() {
105            game_state.set(GameState::Menu);
106        }
107    }
108}
109
110mod game {
111    use bevy::{
112        color::palettes::basic::{BLUE, LIME},
113        prelude::*,
114    };
115
116    use super::{despawn_screen, DisplayQuality, GameState, Volume, TEXT_COLOR};
117
118    // This plugin will contain the game. In this case, it's just be a screen that will
119    // display the current settings for 5 seconds before returning to the menu
120    pub fn game_plugin(app: &mut App) {
121        app.add_systems(OnEnter(GameState::Game), game_setup)
122            .add_systems(Update, game.run_if(in_state(GameState::Game)))
123            .add_systems(OnExit(GameState::Game), despawn_screen::<OnGameScreen>);
124    }
125
126    // Tag component used to tag entities added on the game screen
127    #[derive(Component)]
128    struct OnGameScreen;
129
130    #[derive(Resource, Deref, DerefMut)]
131    struct GameTimer(Timer);
132
133    fn game_setup(
134        mut commands: Commands,
135        display_quality: Res<DisplayQuality>,
136        volume: Res<Volume>,
137    ) {
138        commands.spawn((
139            Node {
140                width: Val::Percent(100.0),
141                height: Val::Percent(100.0),
142                // center children
143                align_items: AlignItems::Center,
144                justify_content: JustifyContent::Center,
145                ..default()
146            },
147            OnGameScreen,
148            children![(
149                Node {
150                    // This will display its children in a column, from top to bottom
151                    flex_direction: FlexDirection::Column,
152                    // `align_items` will align children on the cross axis. Here the main axis is
153                    // vertical (column), so the cross axis is horizontal. This will center the
154                    // children
155                    align_items: AlignItems::Center,
156                    ..default()
157                },
158                BackgroundColor(Color::BLACK),
159                children![
160                    (
161                        Text::new("Will be back to the menu shortly..."),
162                        TextFont {
163                            font_size: 67.0,
164                            ..default()
165                        },
166                        TextColor(TEXT_COLOR),
167                        Node {
168                            margin: UiRect::all(Val::Px(50.0)),
169                            ..default()
170                        },
171                    ),
172                    (
173                        Text::default(),
174                        Node {
175                            margin: UiRect::all(Val::Px(50.0)),
176                            ..default()
177                        },
178                        children![
179                            (
180                                TextSpan(format!("quality: {:?}", *display_quality)),
181                                TextFont {
182                                    font_size: 50.0,
183                                    ..default()
184                                },
185                                TextColor(BLUE.into()),
186                            ),
187                            (
188                                TextSpan::new(" - "),
189                                TextFont {
190                                    font_size: 50.0,
191                                    ..default()
192                                },
193                                TextColor(TEXT_COLOR),
194                            ),
195                            (
196                                TextSpan(format!("volume: {:?}", *volume)),
197                                TextFont {
198                                    font_size: 50.0,
199                                    ..default()
200                                },
201                                TextColor(LIME.into()),
202                            ),
203                        ]
204                    ),
205                ]
206            )],
207        ));
208        // Spawn a 5 seconds timer to trigger going back to the menu
209        commands.insert_resource(GameTimer(Timer::from_seconds(5.0, TimerMode::Once)));
210    }
211
212    // Tick the timer, and change state when finished
213    fn game(
214        time: Res<Time>,
215        mut game_state: ResMut<NextState<GameState>>,
216        mut timer: ResMut<GameTimer>,
217    ) {
218        if timer.tick(time.delta()).finished() {
219            game_state.set(GameState::Menu);
220        }
221    }
examples/ecs/event.rs (line 45)
40fn deal_damage_over_time(
41    time: Res<Time>,
42    mut state: ResMut<DamageTimer>,
43    mut events: EventWriter<DealDamage>,
44) {
45    if state.tick(time.delta()).finished() {
46        // Events can be sent with 'write' and constructed just like any other object.
47        events.write(DealDamage { amount: 10 });
48    }
49}
examples/window/custom_cursor_image.rs (line 120)
115fn execute_animation(time: Res<Time>, mut query: Query<(&mut AnimationConfig, &mut CursorIcon)>) {
116    for (mut config, mut cursor_icon) in &mut query {
117        if let CursorIcon::Custom(CustomCursor::Image(ref mut image)) = *cursor_icon {
118            config.frame_timer.tick(time.delta());
119
120            if config.frame_timer.finished() {
121                if let Some(atlas) = image.texture_atlas.as_mut() {
122                    atlas.index += config.increment;
123
124                    if atlas.index > config.last_sprite_index {
125                        atlas.index = config.first_sprite_index;
126                    }
127
128                    config.frame_timer = AnimationConfig::timer_from_fps(config.fps);
129                }
130            }
131        }
132    }
133}
examples/time/timers.rs (line 65)
58fn countdown(time: Res<Time>, mut countdown: ResMut<Countdown>) {
59    countdown.main_timer.tick(time.delta());
60
61    // The API encourages this kind of timer state checking (if you're only checking for one value)
62    // Additionally, `finished()` would accomplish the same thing as `just_finished` due to the
63    // timer being repeating, however this makes more sense visually.
64    if countdown.percent_trigger.tick(time.delta()).just_finished() {
65        if !countdown.main_timer.finished() {
66            // Print the percent complete the main timer is.
67            info!(
68                "Timer is {:0.0}% complete!",
69                countdown.main_timer.fraction() * 100.0
70            );
71        } else {
72            // The timer has finished so we pause the percent output timer
73            countdown.percent_trigger.pause();
74            info!("Paused percent trigger timer");
75        }
76    }
77}
Source

pub fn just_finished(&self) -> bool

Returns true only on the tick the timer reached its duration.

§Examples
use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, TimerMode::Once);
timer.tick(Duration::from_secs_f32(1.5));
assert!(timer.just_finished());
timer.tick(Duration::from_secs_f32(0.5));
assert!(!timer.just_finished());
Examples found in repository?
examples/ui/ui_scaling.rs (line 118)
117    fn already_completed(&self) -> bool {
118        self.target_time.finished() && !self.target_time.just_finished()
119    }
More examples
Hide additional examples
examples/stress_tests/many_sprites.rs (line 126)
123fn print_sprite_count(time: Res<Time>, mut timer: Local<PrintingTimer>, sprites: Query<&Sprite>) {
124    timer.tick(time.delta());
125
126    if timer.just_finished() {
127        info!("Sprites: {}", sprites.iter().count());
128    }
129}
examples/stress_tests/many_lights.rs (line 148)
145fn print_light_count(time: Res<Time>, mut timer: Local<PrintingTimer>, lights: Query<&PointLight>) {
146    timer.0.tick(time.delta());
147
148    if timer.0.just_finished() {
149        info!("Lights: {}", lights.iter().len());
150    }
151}
152
153struct LogVisibleLights;
154
155impl Plugin for LogVisibleLights {
156    fn build(&self, app: &mut App) {
157        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
158            return;
159        };
160
161        render_app.add_systems(Render, print_visible_light_count.in_set(RenderSet::Prepare));
162    }
163}
164
165// System for printing the number of meshes on every tick of the timer
166fn print_visible_light_count(
167    time: Res<Time>,
168    mut timer: Local<PrintingTimer>,
169    visible: Query<&ExtractedPointLight>,
170    global_light_meta: Res<GlobalClusterableObjectMeta>,
171) {
172    timer.0.tick(time.delta());
173
174    if timer.0.just_finished() {
175        info!(
176            "Visible Lights: {}, Rendered Lights: {}",
177            visible.iter().len(),
178            global_light_meta.entity_to_index.len()
179        );
180    }
181}
examples/ecs/generic_system.rs (line 68)
66fn print_text_system(time: Res<Time>, mut query: Query<(&mut PrinterTick, &TextToPrint)>) {
67    for (mut timer, text) in &mut query {
68        if timer.tick(time.delta()).just_finished() {
69            info!("{}", text.0);
70        }
71    }
72}
examples/time/timers.rs (line 50)
48fn print_when_completed(time: Res<Time>, mut query: Query<&mut PrintOnCompletionTimer>) {
49    for mut timer in &mut query {
50        if timer.tick(time.delta()).just_finished() {
51            info!("Entity timer just finished");
52        }
53    }
54}
55
56/// This system controls ticking the timer within the countdown resource and
57/// handling its state.
58fn countdown(time: Res<Time>, mut countdown: ResMut<Countdown>) {
59    countdown.main_timer.tick(time.delta());
60
61    // The API encourages this kind of timer state checking (if you're only checking for one value)
62    // Additionally, `finished()` would accomplish the same thing as `just_finished` due to the
63    // timer being repeating, however this makes more sense visually.
64    if countdown.percent_trigger.tick(time.delta()).just_finished() {
65        if !countdown.main_timer.finished() {
66            // Print the percent complete the main timer is.
67            info!(
68                "Timer is {:0.0}% complete!",
69                countdown.main_timer.fraction() * 100.0
70            );
71        } else {
72            // The timer has finished so we pause the percent output timer
73            countdown.percent_trigger.pause();
74            info!("Paused percent trigger timer");
75        }
76    }
77}
examples/ui/directional_navigation.rs (line 95)
89fn reset_button_after_interaction(
90    time: Res<Time>,
91    mut query: Query<(&mut ResetTimer, &mut BackgroundColor)>,
92) {
93    for (mut reset_timer, mut color) in query.iter_mut() {
94        reset_timer.tick(time.delta());
95        if reset_timer.just_finished() {
96            color.0 = NORMAL_BUTTON.into();
97        }
98    }
99}
Source

pub fn elapsed(&self) -> Duration

Returns the time elapsed on the timer. Guaranteed to be between 0.0 and duration. Will only equal duration when the timer is finished and non repeating.

See also Stopwatch::elapsed.

§Examples
use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, TimerMode::Once);
timer.tick(Duration::from_secs_f32(0.5));
assert_eq!(timer.elapsed(), Duration::from_secs_f32(0.5));
Source

pub fn elapsed_secs(&self) -> f32

Returns the time elapsed on the timer as an f32. See also Timer::elapsed.

Source

pub fn elapsed_secs_f64(&self) -> f64

Returns the time elapsed on the timer as an f64. See also Timer::elapsed.

Source

pub fn set_elapsed(&mut self, time: Duration)

Sets the elapsed time of the timer without any other considerations.

See also Stopwatch::set.

§
use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, TimerMode::Once);
timer.set_elapsed(Duration::from_secs(2));
assert_eq!(timer.elapsed(), Duration::from_secs(2));
// the timer is not finished even if the elapsed time is greater than the duration.
assert!(!timer.finished());
Examples found in repository?
examples/stress_tests/many_animated_sprites.rs (line 82)
51fn setup(
52    mut commands: Commands,
53    assets: Res<AssetServer>,
54    mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
55) {
56    warn!(include_str!("warning_string.txt"));
57
58    let mut rng = rand::thread_rng();
59
60    let tile_size = Vec2::splat(64.0);
61    let map_size = Vec2::splat(320.0);
62
63    let half_x = (map_size.x / 2.0) as i32;
64    let half_y = (map_size.y / 2.0) as i32;
65
66    let texture_handle = assets.load("textures/rpg/chars/gabe/gabe-idle-run.png");
67    let texture_atlas = TextureAtlasLayout::from_grid(UVec2::splat(24), 7, 1, None, None);
68    let texture_atlas_handle = texture_atlases.add(texture_atlas);
69
70    // Spawns the camera
71
72    commands.spawn(Camera2d);
73
74    // Builds and spawns the sprites
75    for y in -half_y..half_y {
76        for x in -half_x..half_x {
77            let position = Vec2::new(x as f32, y as f32);
78            let translation = (position * tile_size).extend(rng.r#gen::<f32>());
79            let rotation = Quat::from_rotation_z(rng.r#gen::<f32>());
80            let scale = Vec3::splat(rng.r#gen::<f32>() * 2.0);
81            let mut timer = Timer::from_seconds(0.1, TimerMode::Repeating);
82            timer.set_elapsed(Duration::from_secs_f32(rng.r#gen::<f32>()));
83
84            commands.spawn((
85                Sprite {
86                    image: texture_handle.clone(),
87                    texture_atlas: Some(TextureAtlas::from(texture_atlas_handle.clone())),
88                    custom_size: Some(tile_size),
89                    ..default()
90                },
91                Transform {
92                    translation,
93                    rotation,
94                    scale,
95                },
96                AnimationTimer(timer),
97            ));
98        }
99    }
100}
Source

pub fn duration(&self) -> Duration

Returns the duration of the timer.

§Examples
use std::time::Duration;
let timer = Timer::new(Duration::from_secs(1), TimerMode::Once);
assert_eq!(timer.duration(), Duration::from_secs(1));
Source

pub fn set_duration(&mut self, duration: Duration)

Sets the duration of the timer.

§Examples
use std::time::Duration;
let mut timer = Timer::from_seconds(1.5, TimerMode::Once);
timer.set_duration(Duration::from_secs(1));
assert_eq!(timer.duration(), Duration::from_secs(1));
Source

pub fn mode(&self) -> TimerMode

Returns the mode of the timer.

§Examples
let mut timer = Timer::from_seconds(1.0, TimerMode::Repeating);
assert_eq!(timer.mode(), TimerMode::Repeating);
Source

pub fn set_mode(&mut self, mode: TimerMode)

Sets the mode of the timer.

§Examples
let mut timer = Timer::from_seconds(1.0, TimerMode::Repeating);
timer.set_mode(TimerMode::Once);
assert_eq!(timer.mode(), TimerMode::Once);
Source

pub fn tick(&mut self, delta: Duration) -> &Timer

Advance the timer by delta seconds. Non repeating timer will clamp at duration. Repeating timer will wrap around. Will not affect paused timers.

See also Stopwatch::tick.

§Examples
use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, TimerMode::Once);
let mut repeating = Timer::from_seconds(1.0, TimerMode::Repeating);
timer.tick(Duration::from_secs_f32(1.5));
repeating.tick(Duration::from_secs_f32(1.5));
assert_eq!(timer.elapsed_secs(), 1.0);
assert_eq!(repeating.elapsed_secs(), 0.5);
Examples found in repository?
examples/ui/ui_scaling.rs (line 113)
112    fn tick(&mut self, delta: Duration) -> &Self {
113        self.target_time.tick(delta);
114        self
115    }
More examples
Hide additional examples
examples/app/plugin.rs (line 49)
48fn print_message_system(mut state: ResMut<PrintMessageState>, time: Res<Time>) {
49    if state.timer.tick(time.delta()).finished() {
50        info!("{}", state.message);
51    }
52}
examples/stress_tests/many_sprites.rs (line 124)
123fn print_sprite_count(time: Res<Time>, mut timer: Local<PrintingTimer>, sprites: Query<&Sprite>) {
124    timer.tick(time.delta());
125
126    if timer.just_finished() {
127        info!("Sprites: {}", sprites.iter().count());
128    }
129}
examples/stress_tests/many_lights.rs (line 146)
145fn print_light_count(time: Res<Time>, mut timer: Local<PrintingTimer>, lights: Query<&PointLight>) {
146    timer.0.tick(time.delta());
147
148    if timer.0.just_finished() {
149        info!("Lights: {}", lights.iter().len());
150    }
151}
152
153struct LogVisibleLights;
154
155impl Plugin for LogVisibleLights {
156    fn build(&self, app: &mut App) {
157        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
158            return;
159        };
160
161        render_app.add_systems(Render, print_visible_light_count.in_set(RenderSet::Prepare));
162    }
163}
164
165// System for printing the number of meshes on every tick of the timer
166fn print_visible_light_count(
167    time: Res<Time>,
168    mut timer: Local<PrintingTimer>,
169    visible: Query<&ExtractedPointLight>,
170    global_light_meta: Res<GlobalClusterableObjectMeta>,
171) {
172    timer.0.tick(time.delta());
173
174    if timer.0.just_finished() {
175        info!(
176            "Visible Lights: {}, Rendered Lights: {}",
177            visible.iter().len(),
178            global_light_meta.entity_to_index.len()
179        );
180    }
181}
examples/ecs/generic_system.rs (line 68)
66fn print_text_system(time: Res<Time>, mut query: Query<(&mut PrinterTick, &TextToPrint)>) {
67    for (mut timer, text) in &mut query {
68        if timer.tick(time.delta()).just_finished() {
69            info!("{}", text.0);
70        }
71    }
72}
examples/time/timers.rs (line 50)
48fn print_when_completed(time: Res<Time>, mut query: Query<&mut PrintOnCompletionTimer>) {
49    for mut timer in &mut query {
50        if timer.tick(time.delta()).just_finished() {
51            info!("Entity timer just finished");
52        }
53    }
54}
55
56/// This system controls ticking the timer within the countdown resource and
57/// handling its state.
58fn countdown(time: Res<Time>, mut countdown: ResMut<Countdown>) {
59    countdown.main_timer.tick(time.delta());
60
61    // The API encourages this kind of timer state checking (if you're only checking for one value)
62    // Additionally, `finished()` would accomplish the same thing as `just_finished` due to the
63    // timer being repeating, however this makes more sense visually.
64    if countdown.percent_trigger.tick(time.delta()).just_finished() {
65        if !countdown.main_timer.finished() {
66            // Print the percent complete the main timer is.
67            info!(
68                "Timer is {:0.0}% complete!",
69                countdown.main_timer.fraction() * 100.0
70            );
71        } else {
72            // The timer has finished so we pause the percent output timer
73            countdown.percent_trigger.pause();
74            info!("Paused percent trigger timer");
75        }
76    }
77}
Source

pub fn pause(&mut self)

Pauses the Timer. Disables the ticking of the timer.

See also Stopwatch::pause.

§Examples
use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, TimerMode::Once);
timer.pause();
timer.tick(Duration::from_secs_f32(0.5));
assert_eq!(timer.elapsed_secs(), 0.0);
Examples found in repository?
examples/time/timers.rs (line 73)
58fn countdown(time: Res<Time>, mut countdown: ResMut<Countdown>) {
59    countdown.main_timer.tick(time.delta());
60
61    // The API encourages this kind of timer state checking (if you're only checking for one value)
62    // Additionally, `finished()` would accomplish the same thing as `just_finished` due to the
63    // timer being repeating, however this makes more sense visually.
64    if countdown.percent_trigger.tick(time.delta()).just_finished() {
65        if !countdown.main_timer.finished() {
66            // Print the percent complete the main timer is.
67            info!(
68                "Timer is {:0.0}% complete!",
69                countdown.main_timer.fraction() * 100.0
70            );
71        } else {
72            // The timer has finished so we pause the percent output timer
73            countdown.percent_trigger.pause();
74            info!("Paused percent trigger timer");
75        }
76    }
77}
Source

pub fn unpause(&mut self)

Unpauses the Timer. Resumes the ticking of the timer.

See also Stopwatch::unpause().

§Examples
use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, TimerMode::Once);
timer.pause();
timer.tick(Duration::from_secs_f32(0.5));
timer.unpause();
timer.tick(Duration::from_secs_f32(0.5));
assert_eq!(timer.elapsed_secs(), 0.5);
Source

pub fn paused(&self) -> bool

Returns true if the timer is paused.

See also Stopwatch::is_paused.

§Examples
let mut timer = Timer::from_seconds(1.0, TimerMode::Once);
assert!(!timer.paused());
timer.pause();
assert!(timer.paused());
timer.unpause();
assert!(!timer.paused());
Source

pub fn reset(&mut self)

Resets the timer. The reset doesn’t affect the paused state of the timer.

See also Stopwatch::reset.

Examples

use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, TimerMode::Once);
timer.tick(Duration::from_secs_f32(1.5));
timer.reset();
assert!(!timer.finished());
assert!(!timer.just_finished());
assert_eq!(timer.elapsed_secs(), 0.0);
Examples found in repository?
examples/ui/ui_scaling.rs (line 103)
100    fn set_scale(&mut self, scale: f32) {
101        self.start_scale = self.current_scale();
102        self.target_scale = scale;
103        self.target_time.reset();
104    }
More examples
Hide additional examples
examples/games/alien_cake_addict.rs (line 242)
200fn move_player(
201    mut commands: Commands,
202    keyboard_input: Res<ButtonInput<KeyCode>>,
203    mut game: ResMut<Game>,
204    mut transforms: Query<&mut Transform>,
205    time: Res<Time>,
206) {
207    if game.player.move_cooldown.tick(time.delta()).finished() {
208        let mut moved = false;
209        let mut rotation = 0.0;
210
211        if keyboard_input.pressed(KeyCode::ArrowUp) {
212            if game.player.i < BOARD_SIZE_I - 1 {
213                game.player.i += 1;
214            }
215            rotation = -PI / 2.;
216            moved = true;
217        }
218        if keyboard_input.pressed(KeyCode::ArrowDown) {
219            if game.player.i > 0 {
220                game.player.i -= 1;
221            }
222            rotation = PI / 2.;
223            moved = true;
224        }
225        if keyboard_input.pressed(KeyCode::ArrowRight) {
226            if game.player.j < BOARD_SIZE_J - 1 {
227                game.player.j += 1;
228            }
229            rotation = PI;
230            moved = true;
231        }
232        if keyboard_input.pressed(KeyCode::ArrowLeft) {
233            if game.player.j > 0 {
234                game.player.j -= 1;
235            }
236            rotation = 0.0;
237            moved = true;
238        }
239
240        // move on the board
241        if moved {
242            game.player.move_cooldown.reset();
243            *transforms.get_mut(game.player.entity.unwrap()).unwrap() = Transform {
244                translation: Vec3::new(
245                    game.player.i as f32,
246                    game.board[game.player.j][game.player.i].height,
247                    game.player.j as f32,
248                ),
249                rotation: Quat::from_rotation_y(rotation),
250                ..default()
251            };
252        }
253    }
254
255    // eat the cake!
256    if let Some(entity) = game.bonus.entity {
257        if game.player.i == game.bonus.i && game.player.j == game.bonus.j {
258            game.score += 2;
259            game.cake_eaten += 1;
260            commands.entity(entity).despawn();
261            game.bonus.entity = None;
262        }
263    }
264}
Source

pub fn fraction(&self) -> f32

Returns the fraction of the timer elapsed time (goes from 0.0 to 1.0).

§Examples
use std::time::Duration;
let mut timer = Timer::from_seconds(2.0, TimerMode::Once);
timer.tick(Duration::from_secs_f32(0.5));
assert_eq!(timer.fraction(), 0.25);
Examples found in repository?
examples/ui/ui_scaling.rs (line 107)
106    fn current_scale(&self) -> f32 {
107        let completion = self.target_time.fraction();
108        let t = ease_in_expo(completion);
109        self.start_scale.lerp(self.target_scale, t)
110    }
More examples
Hide additional examples
examples/animation/animated_mesh_events.rs (line 203)
191fn simulate_particles(
192    mut commands: Commands,
193    mut query: Query<(Entity, &mut Transform, &mut Particle)>,
194    time: Res<Time>,
195) {
196    for (entity, mut transform, mut particle) in &mut query {
197        if particle.lifetime_timer.tick(time.delta()).just_finished() {
198            commands.entity(entity).despawn();
199            return;
200        }
201
202        transform.translation += particle.velocity * time.delta_secs();
203        transform.scale = Vec3::splat(particle.size.lerp(0.0, particle.lifetime_timer.fraction()));
204        particle
205            .velocity
206            .smooth_nudge(&Vec3::ZERO, 4.0, time.delta_secs());
207    }
208}
examples/time/timers.rs (line 69)
58fn countdown(time: Res<Time>, mut countdown: ResMut<Countdown>) {
59    countdown.main_timer.tick(time.delta());
60
61    // The API encourages this kind of timer state checking (if you're only checking for one value)
62    // Additionally, `finished()` would accomplish the same thing as `just_finished` due to the
63    // timer being repeating, however this makes more sense visually.
64    if countdown.percent_trigger.tick(time.delta()).just_finished() {
65        if !countdown.main_timer.finished() {
66            // Print the percent complete the main timer is.
67            info!(
68                "Timer is {:0.0}% complete!",
69                countdown.main_timer.fraction() * 100.0
70            );
71        } else {
72            // The timer has finished so we pause the percent output timer
73            countdown.percent_trigger.pause();
74            info!("Paused percent trigger timer");
75        }
76    }
77}
Source

pub fn fraction_remaining(&self) -> f32

Returns the fraction of the timer remaining time (goes from 1.0 to 0.0).

§Examples
use std::time::Duration;
let mut timer = Timer::from_seconds(2.0, TimerMode::Once);
timer.tick(Duration::from_secs_f32(0.5));
assert_eq!(timer.fraction_remaining(), 0.75);
Source

pub fn remaining_secs(&self) -> f32

Returns the remaining time in seconds

§Examples
use std::cmp::Ordering;
use std::time::Duration;
let mut timer = Timer::from_seconds(2.0, TimerMode::Once);
timer.tick(Duration::from_secs_f32(0.5));
let result = timer.remaining_secs().total_cmp(&1.5);
assert_eq!(Ordering::Equal, result);
Source

pub fn remaining(&self) -> Duration

Returns the remaining time using Duration

§Examples
use std::time::Duration;
let mut timer = Timer::from_seconds(2.0, TimerMode::Once);
timer.tick(Duration::from_secs_f32(0.5));
assert_eq!(timer.remaining(), Duration::from_secs_f32(1.5));
Source

pub fn times_finished_this_tick(&self) -> u32

Returns the number of times a repeating timer finished during the last tick call.

For non repeating-timers, this method will only ever return 0 or 1.

§Examples
use std::time::Duration;
let mut timer = Timer::from_seconds(1.0, TimerMode::Repeating);
timer.tick(Duration::from_secs_f32(6.0));
assert_eq!(timer.times_finished_this_tick(), 6);
timer.tick(Duration::from_secs_f32(2.0));
assert_eq!(timer.times_finished_this_tick(), 2);
timer.tick(Duration::from_secs_f32(0.5));
assert_eq!(timer.times_finished_this_tick(), 0);

Trait Implementations§

Source§

impl Clone for Timer

Source§

fn clone(&self) -> Timer

Returns a copy of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for Timer

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for Timer

Source§

fn default() -> Timer

Returns the “default value” for a type. Read more
Source§

impl<'de> Deserialize<'de> for Timer

Source§

fn deserialize<__D>( __deserializer: __D, ) -> Result<Timer, <__D as Deserializer<'de>>::Error>
where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
Source§

impl FromArg for &'static Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

type This<'from_arg> = &'from_arg Timer

The type to convert into. Read more
Source§

fn from_arg( arg: Arg<'_>, ) -> Result<<&'static Timer as FromArg>::This<'_>, ArgError>

Creates an item from an argument. Read more
Source§

impl FromArg for &'static mut Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

type This<'from_arg> = &'from_arg mut Timer

The type to convert into. Read more
Source§

fn from_arg( arg: Arg<'_>, ) -> Result<<&'static mut Timer as FromArg>::This<'_>, ArgError>

Creates an item from an argument. Read more
Source§

impl FromArg for Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

type This<'from_arg> = Timer

The type to convert into. Read more
Source§

fn from_arg(arg: Arg<'_>) -> Result<<Timer as FromArg>::This<'_>, ArgError>

Creates an item from an argument. Read more
Source§

impl FromReflect for Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn from_reflect(reflect: &(dyn PartialReflect + 'static)) -> Option<Timer>

Constructs a concrete instance of Self from a reflected value.
Source§

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

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails. Read more
Source§

impl GetOwnership for &Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn ownership() -> Ownership

Returns the ownership of Self.
Source§

impl GetOwnership for &mut Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn ownership() -> Ownership

Returns the ownership of Self.
Source§

impl GetOwnership for Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn ownership() -> Ownership

Returns the ownership of Self.
Source§

impl GetTypeRegistration for Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.
Source§

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type. Read more
Source§

impl IntoReturn for &Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn into_return<'into_return>(self) -> Return<'into_return>
where &Timer: 'into_return,

Converts Self into a Return value.
Source§

impl IntoReturn for &mut Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn into_return<'into_return>(self) -> Return<'into_return>
where &mut Timer: 'into_return,

Converts Self into a Return value.
Source§

impl IntoReturn for Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn into_return<'into_return>(self) -> Return<'into_return>
where Timer: 'into_return,

Converts Self into a Return value.
Source§

impl PartialEq for Timer

Source§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

impl PartialReflect for Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

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

Returns the TypeInfo of the type represented by this value. Read more
Source§

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value. Read more
Source§

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type. Read more
Source§

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

Returns an immutable enumeration of “kinds” of type. Read more
Source§

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

Returns a mutable enumeration of “kinds” of type. Read more
Source§

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

Returns an owned enumeration of “kinds” of type. Read more
Source§

fn try_into_reflect( self: Box<Timer>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.
Source§

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.
Source§

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.
Source§

fn into_partial_reflect(self: Box<Timer>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value. Read more
Source§

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value. Read more
Source§

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value. Read more
Source§

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result. Read more
Source§

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection. Read more
Source§

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value. Read more
Source§

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

👎Deprecated since 0.16.0: to clone reflected values, prefer using reflect_clone. To convert reflected values to dynamic ones, use to_dynamic.
Clones Self into its dynamic representation. Read more
Source§

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind. Read more
Source§

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

Returns a hash of the value (which includes the type). Read more
Source§

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

Debug formatter for the value. Read more
Source§

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type. Read more
Source§

impl Reflect for Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

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

Returns the value as a Box<dyn Any>. Read more
Source§

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any. Read more
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any. Read more
Source§

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

Casts this type to a boxed, fully-reflected value.
Source§

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.
Source§

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.
Source§

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

Performs a type-checked assignment of a reflected value to this value. Read more
Source§

impl Serialize for Timer

Source§

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>
where __S: Serializer,

Serialize this value into the given Serde serializer. Read more
Source§

impl Struct for Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field named name as a &dyn PartialReflect.
Source§

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

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

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field with index index as a &dyn PartialReflect.
Source§

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

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

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

Returns the name of the field with index index.
Source§

fn field_len(&self) -> usize

Returns the number of fields in the struct.
Source§

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

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

fn to_dynamic_struct(&self) -> DynamicStruct

Source§

fn clone_dynamic(&self) -> DynamicStruct

👎Deprecated since 0.16.0: use to_dynamic_struct instead
Clones the struct into a DynamicStruct.
Source§

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.
Source§

impl TypePath for Timer
where Timer: Any + Send + Sync,

Source§

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type. Read more
Source§

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type. Read more
Source§

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

Returns the name of the type, or None if it is anonymous. Read more
Source§

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

Returns the name of the crate the type is in, or None if it is anonymous. Read more
Source§

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

Returns the path to the module the type is in, or None if it is anonymous. Read more
Source§

impl Typed for Timer
where Timer: Any + Send + Sync, Stopwatch: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Duration: FromReflect + TypePath + MaybeTyped + RegisterForReflection, TimerMode: FromReflect + TypePath + MaybeTyped + RegisterForReflection, bool: FromReflect + TypePath + MaybeTyped + RegisterForReflection, u32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

Source§

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.
Source§

impl Eq for Timer

Source§

impl StructuralPartialEq for Timer

Auto Trait Implementations§

§

impl Freeze for Timer

§

impl RefUnwindSafe for Timer

§

impl Send for Timer

§

impl Sync for Timer

§

impl Unpin for Timer

§

impl UnwindSafe for Timer

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

Source§

fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

Return the T ShaderType for self. When used in AsBindGroup derives, it is safe to assume that all images in self exist.
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> Conv for T

Source§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
Source§

impl<T> Downcast<T> for T

Source§

fn downcast(&self) -> &T

Source§

impl<T> Downcast for T
where T: Any,

Source§

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

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

fn as_any(&self) -> &(dyn Any + 'static)

Converts &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Converts &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> Downcast for T
where T: Any,

Source§

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

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> DowncastSend for T
where T: Any + Send,

Source§

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

Source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> DynEq for T
where T: Any + Eq,

Source§

fn as_any(&self) -> &(dyn Any + 'static)

Casts the type to dyn Any.
Source§

fn dyn_eq(&self, other: &(dyn DynEq + 'static)) -> bool

This method tests for self and other values to be equal. Read more
Source§

impl<T> DynamicTypePath for T
where T: TypePath,

Source§

impl<T> DynamicTyped for T
where T: Typed,

Source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
Source§

impl<T> FmtForward for T

Source§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
Source§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
Source§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
Source§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
Source§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
Source§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
Source§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
Source§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
Source§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<S> FromSample<S> for S

Source§

fn from_sample_(s: S) -> S

Source§

impl<T> FromWorld for T
where T: Default,

Source§

fn from_world(_world: &mut World) -> T

Creates Self using default().

Source§

impl<S> GetField for S
where S: Struct,

Source§

fn get_field<T>(&self, name: &str) -> Option<&T>
where T: Reflect,

Returns a reference to the value of the field named name, downcast to T.
Source§

fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>
where T: Reflect,

Returns a mutable reference to the value of the field named name, downcast to T.
Source§

impl<T> GetPath for T
where T: Reflect + ?Sized,

Source§

fn reflect_path<'p>( &self, path: impl ReflectPath<'p>, ) -> Result<&(dyn PartialReflect + 'static), ReflectPathError<'p>>

Returns a reference to the value specified by path. Read more
Source§

fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut (dyn PartialReflect + 'static), ReflectPathError<'p>>

Returns a mutable reference to the value specified by path. Read more
Source§

fn path<'p, T>( &self, path: impl ReflectPath<'p>, ) -> Result<&T, ReflectPathError<'p>>
where T: Reflect,

Returns a statically typed reference to the value specified by path. Read more
Source§

fn path_mut<'p, T>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut T, ReflectPathError<'p>>
where T: Reflect,

Returns a statically typed mutable reference to the value specified by path. Read more
Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<F, T> IntoSample<T> for F
where T: FromSample<F>,

Source§

fn into_sample(self) -> T

Source§

impl<T> NoneValue for T
where T: Default,

Source§

type NoneType = T

Source§

fn null_value() -> T

The none-equivalent value.
Source§

impl<T> Pipe for T
where T: ?Sized,

Source§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
Source§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
Source§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
Source§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
Source§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
Source§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
Source§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<R, P> ReadPrimitive<R> for P
where R: Read + ReadEndian<P>, P: Default,

Source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
Source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
Source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
Source§

impl<T> Serialize for T
where T: Serialize + ?Sized,

Source§

fn erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<(), Error>

Source§

fn do_erased_serialize( &self, serializer: &mut dyn Serializer, ) -> Result<(), ErrorImpl>

Source§

impl<T> Tap for T

Source§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
Source§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
Source§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
Source§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
Source§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
Source§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
Source§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
Source§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
Source§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
Source§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> ToSample<U> for T
where U: FromSample<T>,

Source§

fn to_sample_(self) -> U

Source§

impl<T> TryConv for T

Source§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> TypeData for T
where T: 'static + Send + Sync + Clone,

Source§

impl<T> Upcast<T> for T

Source§

fn upcast(&self) -> Option<&T>

Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<T> ConditionalSend for T
where T: Send,

Source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,

Source§

impl<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,

Source§

impl<T> Reflectable for T

Source§

impl<T> Settings for T
where T: 'static + Send + Sync,

Source§

impl<T> WasmNotSend for T
where T: Send,

Source§

impl<T> WasmNotSendSync for T

Source§

impl<T> WasmNotSync for T
where T: Sync,