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() -> Stopwatch

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));

pub fn elapsed_secs(&self) -> f32

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) -> &Stopwatch

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

pub fn clone(&self) -> Stopwatch

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Stopwatch

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

Formats the value using the given formatter.

impl Default for Stopwatch

pub fn default() -> Stopwatch

Returns the “default value” for a type.

impl GetTypeRegistration for Stopwatch

pub fn get_type_registration() -> TypeRegistration

impl Reflect for Stopwatch

pub fn type_name(&self) -> &str

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

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

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

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

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

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

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

pub 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.

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

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

impl Struct for Stopwatch

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

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

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

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

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

pub fn field_len(&self) -> usize

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

pub fn clone_dynamic(&self) -> DynamicStruct