Struct bevy_core::Stopwatch

pub struct Stopwatch { /* fields omitted */ }

A Stopwatch is a struct that track elapsed time when started.

Examples

use std::time::Duration;
let mut stopwatch = Stopwatch::new();
assert_eq!(stopwatch.elapsed_secs(), 0.0);

stopwatch.tick(Duration::from_secs_f32(1.0)); // tick one second
assert_eq!(stopwatch.elapsed_secs(), 1.0);

stopwatch.pause();
stopwatch.tick(Duration::from_secs_f32(1.0)); // paused stopwatches don't tick
assert_eq!(stopwatch.elapsed_secs(), 1.0);

stopwatch.reset(); // reset the stopwatch
assert!(stopwatch.paused());
assert_eq!(stopwatch.elapsed_secs(), 0.0);

Implementations

impl Stopwatch

pub fn new() -> Self

Create a new unpaused Stopwatch with no elapsed time.

Examples

let stopwatch = Stopwatch::new();
assert_eq!(stopwatch.elapsed_secs(), 0.0);
assert_eq!(stopwatch.paused(), false);

pub fn elapsed(&self) -> Duration

Returns the elapsed time since the last reset of the stopwatch.

Examples

use std::time::Duration;
let mut stopwatch = Stopwatch::new();
stopwatch.tick(Duration::from_secs(1));
assert_eq!(stopwatch.elapsed(), Duration::from_secs(1));

See Also

elapsed_secs - if a f32 value is desirable instead.

pub fn elapsed_secs(&self) -> f32

Returns the elapsed time since the last reset of the stopwatch, in seconds.

Examples

use std::time::Duration;
let mut stopwatch = Stopwatch::new();
stopwatch.tick(Duration::from_secs(1));
assert_eq!(stopwatch.elapsed_secs(), 1.0);

See Also

elapsed - if a Duration is desirable instead.

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

Sets the elapsed time of the stopwatch.

Examples

use std::time::Duration;
let mut stopwatch = Stopwatch::new();
stopwatch.set_elapsed(Duration::from_secs_f32(1.0));
assert_eq!(stopwatch.elapsed_secs(), 1.0);

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

Advance the stopwatch by delta seconds. If the stopwatch is paused, ticking will not have any effect on elapsed time.

Examples

use std::time::Duration;
let mut stopwatch = Stopwatch::new();
stopwatch.tick(Duration::from_secs_f32(1.5));
assert_eq!(stopwatch.elapsed_secs(), 1.5);

pub fn pause(&mut self)

Pauses the stopwatch. Any call to tick while paused will not have any effect on the elapsed time.

Examples

use std::time::Duration;
let mut stopwatch = Stopwatch::new();
stopwatch.pause();
stopwatch.tick(Duration::from_secs_f32(1.5));
assert!(stopwatch.paused());
assert_eq!(stopwatch.elapsed_secs(), 0.0);

pub fn unpause(&mut self)

Unpauses the stopwatch. Resume the effect of ticking on elapsed time.

Examples

use std::time::Duration;
let mut stopwatch = Stopwatch::new();
stopwatch.pause();
stopwatch.tick(Duration::from_secs_f32(1.0));
stopwatch.unpause();
stopwatch.tick(Duration::from_secs_f32(1.0));
assert!(!stopwatch.paused());
assert_eq!(stopwatch.elapsed_secs(), 1.0);

pub fn paused(&self) -> bool

Returns true if the stopwatch is paused.

Examples

let mut stopwatch = Stopwatch::new();
assert!(!stopwatch.paused());
stopwatch.pause();
assert!(stopwatch.paused());
stopwatch.unpause();
assert!(!stopwatch.paused());

pub fn reset(&mut self)

Resets the stopwatch.

Examples

use std::time::Duration;
let mut stopwatch = Stopwatch::new();
stopwatch.tick(Duration::from_secs_f32(1.5));
stopwatch.reset();
assert_eq!(stopwatch.elapsed_secs(), 0.0);

Trait Implementations

impl Clone for Stopwatch

fn clone(&self) -> Stopwatch

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for Stopwatch where
    Self: Send + Sync + 'static, 

type Storage = TableStorage

impl Debug for Stopwatch

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

Formats the value using the given formatter.

impl Default for Stopwatch

fn default() -> Stopwatch

Returns the “default value” for a type.

impl GetTypeRegistration for Stopwatch

fn get_type_registration() -> TypeRegistration

impl Reflect for Stopwatch

fn type_name(&self) -> &str

fn any(&self) -> &dyn Any

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

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

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

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

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

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

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

Returns a serializable value, if serialization is supported. Otherwise None will be returned.

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

Returns a hash of the value (which includes the type) if hashing is supported. Otherwise None will be returned.

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

Returns a “partial equal” comparison result if comparison is supported. Otherwise None will be returned.

impl Struct for Stopwatch

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

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

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

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

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

fn field_len(&self) -> usize

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

fn clone_dynamic(&self) -> DynamicStruct