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
impl Timer
Sourcepub fn new(duration: Duration, mode: TimerMode) -> Timer
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?
More examples
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}
Sourcepub fn from_seconds(duration: f32, mode: TimerMode) -> Timer
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?
More examples
- examples/ui/font_atlas_debug.rs
- examples/time/timers.rs
- examples/ecs/generic_system.rs
- examples/audio/soundtrack.rs
- examples/ui/directional_navigation.rs
- examples/games/alien_cake_addict.rs
- examples/games/game_menu.rs
- examples/2d/sprite_sheet.rs
- examples/animation/animated_mesh_events.rs
- examples/picking/sprite_picking.rs
- examples/input/text_input.rs
- examples/stress_tests/many_animated_sprites.rs
- examples/2d/sprite_scale.rs
Sourcepub fn finished(&self) -> bool
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?
More examples
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 }
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}
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}
Sourcepub fn just_finished(&self) -> bool
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?
More examples
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}
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/stress_tests/many_cubes.rs
- examples/audio/soundtrack.rs
- examples/input/text_input.rs
- examples/ui/font_atlas_debug.rs
- examples/2d/sprite_scale.rs
- examples/2d/sprite_sheet.rs
- examples/picking/sprite_picking.rs
- examples/stress_tests/many_animated_sprites.rs
- examples/animation/animated_mesh_events.rs
- examples/stress_tests/many_text2d.rs
- examples/2d/sprite_animation.rs
- examples/games/contributors.rs
Sourcepub fn elapsed(&self) -> Duration
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));
Sourcepub fn elapsed_secs(&self) -> f32
pub fn elapsed_secs(&self) -> f32
Returns the time elapsed on the timer as an f32
.
See also Timer::elapsed
.
Sourcepub fn elapsed_secs_f64(&self) -> f64
pub fn elapsed_secs_f64(&self) -> f64
Returns the time elapsed on the timer as an f64
.
See also Timer::elapsed
.
Sourcepub fn set_elapsed(&mut self, time: Duration)
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?
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}
Sourcepub fn duration(&self) -> Duration
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));
Sourcepub fn set_duration(&mut self, duration: Duration)
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));
Sourcepub fn mode(&self) -> TimerMode
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);
Sourcepub fn set_mode(&mut self, mode: TimerMode)
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);
Sourcepub fn tick(&mut self, delta: Duration) -> &Timer
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?
More examples
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}
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/games/game_menu.rs
- examples/ecs/event.rs
- examples/ui/directional_navigation.rs
- examples/stress_tests/many_cubes.rs
- examples/audio/soundtrack.rs
- examples/input/text_input.rs
- examples/ui/font_atlas_debug.rs
- examples/2d/sprite_scale.rs
- examples/2d/sprite_sheet.rs
- examples/picking/sprite_picking.rs
- examples/stress_tests/many_animated_sprites.rs
- examples/animation/animated_mesh_events.rs
- examples/stress_tests/many_text2d.rs
- examples/window/custom_cursor_image.rs
- examples/2d/sprite_animation.rs
- examples/games/contributors.rs
- examples/games/alien_cake_addict.rs
Sourcepub fn pause(&mut self)
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?
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}
Sourcepub fn unpause(&mut self)
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);
Sourcepub fn paused(&self) -> bool
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());
Sourcepub fn reset(&mut self)
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?
More examples
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}
Sourcepub fn fraction(&self) -> f32
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?
More examples
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}
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}
Sourcepub fn fraction_remaining(&self) -> f32
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);
Sourcepub fn remaining_secs(&self) -> f32
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);
Sourcepub fn remaining(&self) -> Duration
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));
Sourcepub fn times_finished_this_tick(&self) -> u32
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<'de> Deserialize<'de> for Timer
impl<'de> Deserialize<'de> for Timer
Source§fn deserialize<__D>(
__deserializer: __D,
) -> Result<Timer, <__D as Deserializer<'de>>::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(
__deserializer: __D,
) -> Result<Timer, <__D as Deserializer<'de>>::Error>where
__D: Deserializer<'de>,
Source§impl FromArg for &'static Timerwhere
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,
impl FromArg for &'static Timerwhere
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§impl FromArg for &'static mut Timerwhere
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,
impl FromArg for &'static mut Timerwhere
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§impl FromArg for Timerwhere
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,
impl FromArg for Timerwhere
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§impl FromReflect for Timerwhere
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,
impl FromReflect for Timerwhere
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>
fn from_reflect(reflect: &(dyn PartialReflect + 'static)) -> Option<Timer>
Self
from a reflected value.Source§fn take_from_reflect(
reflect: Box<dyn PartialReflect>,
) -> Result<Self, Box<dyn PartialReflect>>
fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>
Self
using,
constructing the value using from_reflect
if that fails. Read moreSource§impl GetOwnership for &Timerwhere
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,
impl GetOwnership for &Timerwhere
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§impl GetOwnership for &mut Timerwhere
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,
impl GetOwnership for &mut Timerwhere
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§impl GetOwnership for Timerwhere
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,
impl GetOwnership for Timerwhere
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§impl GetTypeRegistration for Timerwhere
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,
impl GetTypeRegistration for Timerwhere
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
fn get_type_registration() -> TypeRegistration
TypeRegistration
for this type.Source§fn register_type_dependencies(registry: &mut TypeRegistry)
fn register_type_dependencies(registry: &mut TypeRegistry)
Source§impl IntoReturn for &Timerwhere
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,
impl IntoReturn for &Timerwhere
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§impl IntoReturn for &mut Timerwhere
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,
impl IntoReturn for &mut Timerwhere
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§impl IntoReturn for Timerwhere
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,
impl IntoReturn for Timerwhere
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§impl PartialReflect for Timerwhere
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,
impl PartialReflect for Timerwhere
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>
fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
Source§fn try_apply(
&mut self,
value: &(dyn PartialReflect + 'static),
) -> Result<(), ApplyError>
fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>
Source§fn reflect_kind(&self) -> ReflectKind
fn reflect_kind(&self) -> ReflectKind
Source§fn reflect_ref(&self) -> ReflectRef<'_>
fn reflect_ref(&self) -> ReflectRef<'_>
Source§fn reflect_mut(&mut self) -> ReflectMut<'_>
fn reflect_mut(&mut self) -> ReflectMut<'_>
Source§fn reflect_owned(self: Box<Timer>) -> ReflectOwned
fn reflect_owned(self: Box<Timer>) -> ReflectOwned
Source§fn try_into_reflect(
self: Box<Timer>,
) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>
fn try_into_reflect( self: Box<Timer>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>
Source§fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>
fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>
Source§fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>
fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>
Source§fn into_partial_reflect(self: Box<Timer>) -> Box<dyn PartialReflect>
fn into_partial_reflect(self: Box<Timer>) -> Box<dyn PartialReflect>
Source§fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)
fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)
Source§fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)
fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)
Source§fn reflect_partial_eq(
&self,
value: &(dyn PartialReflect + 'static),
) -> Option<bool>
fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>
Source§fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>
fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>
Self
using reflection. Read moreSource§fn apply(&mut self, value: &(dyn PartialReflect + 'static))
fn apply(&mut self, value: &(dyn PartialReflect + 'static))
Source§fn clone_value(&self) -> Box<dyn PartialReflect>
fn clone_value(&self) -> Box<dyn PartialReflect>
reflect_clone
. To convert reflected values to dynamic ones, use to_dynamic
.Self
into its dynamic representation. Read moreSource§fn to_dynamic(&self) -> Box<dyn PartialReflect>
fn to_dynamic(&self) -> Box<dyn PartialReflect>
Source§fn reflect_hash(&self) -> Option<u64>
fn reflect_hash(&self) -> Option<u64>
Source§fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>
fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Source§fn is_dynamic(&self) -> bool
fn is_dynamic(&self) -> bool
Source§impl Reflect for Timerwhere
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,
impl Reflect for Timerwhere
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 as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut dyn Any
. Read moreSource§fn into_reflect(self: Box<Timer>) -> Box<dyn Reflect>
fn into_reflect(self: Box<Timer>) -> Box<dyn Reflect>
Source§fn as_reflect(&self) -> &(dyn Reflect + 'static)
fn as_reflect(&self) -> &(dyn Reflect + 'static)
Source§fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)
fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)
Source§impl Serialize for Timer
impl Serialize for Timer
Source§fn serialize<__S>(
&self,
__serializer: __S,
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,
fn serialize<__S>(
&self,
__serializer: __S,
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,
Source§impl Struct for Timerwhere
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,
impl Struct for Timerwhere
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)>
fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>
name
as a &dyn PartialReflect
.Source§fn field_mut(
&mut self,
name: &str,
) -> Option<&mut (dyn PartialReflect + 'static)>
fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>
name
as a
&mut dyn PartialReflect
.Source§fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>
fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>
index
as a
&dyn PartialReflect
.Source§fn field_at_mut(
&mut self,
index: usize,
) -> Option<&mut (dyn PartialReflect + 'static)>
fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>
index
as a &mut dyn PartialReflect
.Source§fn name_at(&self, index: usize) -> Option<&str>
fn name_at(&self, index: usize) -> Option<&str>
index
.Source§fn iter_fields(&self) -> FieldIter<'_> ⓘ
fn iter_fields(&self) -> FieldIter<'_> ⓘ
fn to_dynamic_struct(&self) -> DynamicStruct
Source§fn clone_dynamic(&self) -> DynamicStruct
fn clone_dynamic(&self) -> DynamicStruct
to_dynamic_struct
insteadDynamicStruct
.Source§fn get_represented_struct_info(&self) -> Option<&'static StructInfo>
fn get_represented_struct_info(&self) -> Option<&'static StructInfo>
None
if TypeInfo
is not available.Source§impl TypePath for Timer
impl TypePath for Timer
Source§fn type_path() -> &'static str
fn type_path() -> &'static str
Source§fn short_type_path() -> &'static str
fn short_type_path() -> &'static str
Source§fn type_ident() -> Option<&'static str>
fn type_ident() -> Option<&'static str>
Source§fn crate_name() -> Option<&'static str>
fn crate_name() -> Option<&'static str>
Source§impl Typed for Timerwhere
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,
impl Typed for Timerwhere
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,
impl Eq for Timer
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, U> AsBindGroupShaderType<U> for T
impl<T, U> AsBindGroupShaderType<U> for T
Source§fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U
fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U
T
ShaderType
for self
. When used in AsBindGroup
derives, it is safe to assume that all images in self
exist.Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
Source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
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>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
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)
fn as_any(&self) -> &(dyn Any + 'static)
&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)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&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 Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
Source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
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>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
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)
fn as_any(&self) -> &(dyn Any + 'static)
&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)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&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
impl<T> DowncastSend for T
Source§impl<T> DowncastSync for T
impl<T> DowncastSync for T
Source§impl<T> DynamicTypePath for Twhere
T: TypePath,
impl<T> DynamicTypePath for Twhere
T: TypePath,
Source§fn reflect_type_path(&self) -> &str
fn reflect_type_path(&self) -> &str
TypePath::type_path
.Source§fn reflect_short_type_path(&self) -> &str
fn reflect_short_type_path(&self) -> &str
Source§fn reflect_type_ident(&self) -> Option<&str>
fn reflect_type_ident(&self) -> Option<&str>
TypePath::type_ident
.Source§fn reflect_crate_name(&self) -> Option<&str>
fn reflect_crate_name(&self) -> Option<&str>
TypePath::crate_name
.Source§fn reflect_module_path(&self) -> Option<&str>
fn reflect_module_path(&self) -> Option<&str>
Source§impl<T> DynamicTyped for Twhere
T: Typed,
impl<T> DynamicTyped for Twhere
T: Typed,
Source§fn reflect_type_info(&self) -> &'static TypeInfo
fn reflect_type_info(&self) -> &'static TypeInfo
Typed::type_info
.Source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
Source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.Source§impl<T> FmtForward for T
impl<T> FmtForward for T
Source§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.Source§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self
to use its Display
implementation when
Debug
-formatted.Source§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.Source§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.Source§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.Source§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.Source§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.Source§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.Source§impl<S> FromSample<S> for S
impl<S> FromSample<S> for S
fn from_sample_(s: S) -> S
Source§impl<T> FromWorld for Twhere
T: Default,
impl<T> FromWorld for Twhere
T: Default,
Source§fn from_world(_world: &mut World) -> T
fn from_world(_world: &mut World) -> T
Creates Self
using default()
.
Source§impl<S> GetField for Swhere
S: Struct,
impl<S> GetField for Swhere
S: Struct,
Source§impl<T> GetPath for T
impl<T> GetPath for T
Source§fn reflect_path<'p>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&(dyn PartialReflect + 'static), ReflectPathError<'p>>
fn reflect_path<'p>( &self, path: impl ReflectPath<'p>, ) -> Result<&(dyn PartialReflect + 'static), ReflectPathError<'p>>
path
. Read moreSource§fn reflect_path_mut<'p>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut (dyn PartialReflect + 'static), ReflectPathError<'p>>
fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut (dyn PartialReflect + 'static), ReflectPathError<'p>>
path
. Read moreSource§fn path<'p, T>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
fn path<'p, T>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
path
. Read moreSource§fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
path
. Read moreSource§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
Source§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
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 moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
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 moreSource§impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,
impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,
fn into_sample(self) -> T
Source§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
Source§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
Source§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read moreSource§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read moreSource§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
Source§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
Source§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
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
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
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
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self
, then passes self.deref()
into the pipe function.Source§impl<T> Pointable for T
impl<T> Pointable for T
Source§impl<R, P> ReadPrimitive<R> for P
impl<R, P> ReadPrimitive<R> for P
Source§fn read_from_little_endian(read: &mut R) -> Result<Self, Error>
fn read_from_little_endian(read: &mut R) -> Result<Self, Error>
ReadEndian::read_from_little_endian()
.Source§impl<T> Serialize for T
impl<T> Serialize for T
fn erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<(), Error>
fn do_erased_serialize( &self, serializer: &mut dyn Serializer, ) -> Result<(), ErrorImpl>
Source§impl<T> Tap for T
impl<T> Tap for T
Source§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B>
of a value. Read moreSource§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B>
of a value. Read moreSource§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R>
view of a value. Read moreSource§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R>
view of a value. Read moreSource§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target
of a value. Read moreSource§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target
of a value. Read moreSource§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.Source§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.Source§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.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
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.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
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.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
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.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
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref()
only in debug builds, and is erased in release
builds.