Struct bevy::time::Time

pub struct Time { /* private fields */ }

A clock that tracks how much it has advanced (and how much real time has elapsed) since its previous update and since its creation.

Implementations

impl Time

pub fn new(startup: Instant) -> Time

Constructs a new Time instance with a specific startup Instant.

pub fn update(&mut self)

Updates the internal time measurements.

Calling this method as part of your app will most likely result in inaccurate timekeeping, as the Time resource is ordinarily managed by the TimePlugin.

pub fn update_with_instant(&mut self, instant: Instant)

Updates time with a specified Instant.

This method is provided for use in tests. Calling this method as part of your app will most likely result in inaccurate timekeeping, as the Time resource is ordinarily managed by the TimePlugin.

Examples

#[derive(Resource)]
struct Health {
    // Health value between 0.0 and 1.0
    health_value: f32,
}

fn health_system(time: Res<Time>, mut health: ResMut<Health>) {
    // Increase health value by 0.1 per second, independent of frame rate,
    // but not beyond 1.0
    health.health_value = (health.health_value + 0.1 * time.delta_seconds()).min(1.0);
}

// Mock time in tests
fn test_health_system() {
    let mut world = World::default();
    let mut time = Time::default();
    time.update();
    world.insert_resource(time);
    world.insert_resource(Health { health_value: 0.2 });

    let mut schedule = Schedule::new();
    schedule.add_system(health_system);

    // Simulate that 30 ms have passed
    let mut time = world.resource_mut::<Time>();
    let last_update = time.last_update().unwrap();
    time.update_with_instant(last_update + Duration::from_millis(30));

    // Run system
    schedule.run(&mut world);

    // Check that 0.003 has been added to the health value
    let expected_health_value = 0.2 + 0.1 * 0.03;
    let actual_health_value = world.resource::<Health>().health_value;
    assert_eq!(expected_health_value, actual_health_value);
}

pub fn startup(&self) -> Instant

Returns the Instant the clock was created.

This usually represents when the app was started.

pub fn first_update(&self) -> Option<Instant>

Returns the Instant when update was first called, if it exists.

This usually represents when the first app update started.

pub fn last_update(&self) -> Option<Instant>

Returns the Instant when update was last called, if it exists.

This usually represents when the current app update started.

pub fn delta(&self) -> Duration

Returns how much time has advanced since the last update, as a Duration.

pub fn delta_seconds(&self) -> f32

Returns how much time has advanced since the last update, as f32 seconds.

pub fn delta_seconds_f64(&self) -> f64

Returns how much time has advanced since the last update, as f64 seconds.

pub fn elapsed(&self) -> Duration

Returns how much time has advanced since startup, as Duration.

pub fn elapsed_seconds(&self) -> f32

Returns how much time has advanced since startup, as f32 seconds.

Note: This is a monotonically increasing value. It’s precision will degrade over time. If you need an f32 but that precision loss is unacceptable, use elapsed_seconds_wrapped.

pub fn elapsed_seconds_f64(&self) -> f64

Returns how much time has advanced since startup, as f64 seconds.

pub fn elapsed_wrapped(&self) -> Duration

Returns how much time has advanced since startup modulo the wrap_period, as Duration.

pub fn elapsed_seconds_wrapped(&self) -> f32

Returns how much time has advanced since startup modulo the wrap_period, as f32 seconds.

This method is intended for applications (e.g. shaders) that require an f32 value but suffer from the gradual precision loss of elapsed_seconds.

pub fn elapsed_seconds_wrapped_f64(&self) -> f64

Returns how much time has advanced since startup modulo the wrap_period, as f64 seconds.

pub fn raw_delta(&self) -> Duration

Returns how much real time has elapsed since the last update, as a Duration.

pub fn raw_delta_seconds(&self) -> f32

Returns how much real time has elapsed since the last update, as f32 seconds.

pub fn raw_delta_seconds_f64(&self) -> f64

Returns how much real time has elapsed since the last update, as f64 seconds.

pub fn raw_elapsed(&self) -> Duration

Returns how much real time has elapsed since startup, as Duration.

pub fn raw_elapsed_seconds(&self) -> f32

Returns how much real time has elapsed since startup, as f32 seconds.

Note: This is a monotonically increasing value. It’s precision will degrade over time. If you need an f32 but that precision loss is unacceptable, use raw_elapsed_seconds_wrapped.

pub fn raw_elapsed_seconds_f64(&self) -> f64

Returns how much real time has elapsed since startup, as f64 seconds.

pub fn raw_elapsed_wrapped(&self) -> Duration

Returns how much real time has elapsed since startup modulo the wrap_period, as Duration.

pub fn raw_elapsed_seconds_wrapped(&self) -> f32

Returns how much real time has elapsed since startup modulo the wrap_period, as f32 seconds.

This method is intended for applications (e.g. shaders) that require an f32 value but suffer from the gradual precision loss of raw_elapsed_seconds.

pub fn raw_elapsed_seconds_wrapped_f64(&self) -> f64

Returns how much real time has elapsed since startup modulo the wrap_period, as f64 seconds.

pub fn wrap_period(&self) -> Duration

Returns the modulus used to calculate elapsed_wrapped and raw_elapsed_wrapped.

Note: The default modulus is one hour.

pub fn set_wrap_period(&mut self, wrap_period: Duration)

Sets the modulus used to calculate elapsed_wrapped and raw_elapsed_wrapped.

Note: This will not take effect until the next update.

Panics

Panics if wrap_period is a zero-length duration.

pub fn relative_speed(&self) -> f32

Returns the speed the clock advances relative to your system clock, as f32. This is known as “time scaling” or “time dilation” in other engines.

Note: This function will return zero when time is paused.

pub fn relative_speed_f64(&self) -> f64

Returns the speed the clock advances relative to your system clock, as f64. This is known as “time scaling” or “time dilation” in other engines.

Note: This function will return zero when time is paused.

pub fn set_relative_speed(&mut self, ratio: f32)

Sets the speed the clock advances relative to your system clock, given as an f32.

For example, setting this to 2.0 will make the clock advance twice as fast as your system clock.

Note: This does not affect the raw_* measurements.

Panics

Panics if ratio is negative or not finite.

pub fn set_relative_speed_f64(&mut self, ratio: f64)

Sets the speed the clock advances relative to your system clock, given as an f64.

For example, setting this to 2.0 will make the clock advance twice as fast as your system clock.

Note: This does not affect the raw_* measurements.

Panics

Panics if ratio is negative or not finite.

pub fn pause(&mut self)

Stops the clock, preventing it from advancing until resumed.

Note: This does not affect the raw_* measurements.

pub fn unpause(&mut self)

Resumes the clock if paused.

pub fn is_paused(&self) -> bool

Returns true if the clock is currently paused.

Trait Implementations

impl Clone for Time

fn clone(&self) -> Time

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Time

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

Formats the value using the given formatter.

impl Default for Time

fn default() -> Time

Returns the “default value” for a type.

impl FromReflect for Timewhere Instant: FromReflect, Option<Instant>: FromReflect, bool: FromReflect, f64: FromReflect, Duration: FromReflect, f32: FromReflect,

fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<Time>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn Reflect + 'static, Global> ) -> Result<Self, Box<dyn Reflect + 'static, Global>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for Timewhere Instant: Reflect, Option<Instant>: Reflect, bool: Reflect, f64: Reflect, Duration: Reflect, f32: Reflect,

fn get_type_registration() -> TypeRegistration

impl Reflect for Timewhere Instant: Reflect, Option<Instant>: Reflect, bool: Reflect, f64: Reflect, Duration: Reflect, f32: Reflect,

fn type_name(&self) -> &str

Returns the type name of the underlying type.

fn get_type_info(&self) -> &'static TypeInfo

Returns the TypeInfo of the underlying type.

fn into_any(self: Box<Time, Global>) -> Box<dyn Any + 'static, Global>

Returns the value as a Box<dyn Any>.

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

Returns the value as a &dyn Any.

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

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Time, Global>) -> Box<dyn Reflect + 'static, Global>

Casts this type to a boxed reflected value.

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

Casts this type to a reflected value.

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

Casts this type to a mutable reflected value.

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

Clones the value as a Reflect trait object.

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

Performs a type-checked assignment of a reflected value to this value.

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

Applies a reflected value to this value.

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

Returns an enumeration of “kinds” of type.

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

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Time, Global>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

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

Returns a “partial equality” comparison result.

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

Returns a hash of the value (which includes the type).

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

Debug formatter for the value.

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

Returns a serializable version of the value.

impl Struct for Timewhere Instant: Reflect, Option<Instant>: Reflect, bool: Reflect, f64: Reflect, Duration: Reflect, f32: Reflect,

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

Returns a reference to the value of the field named name as a &dyn Reflect.

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

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

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

Returns a reference to the value of the field with index index as a &dyn Reflect.

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

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

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

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

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

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

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

impl Typed for Timewhere Instant: Reflect, Option<Instant>: Reflect, bool: Reflect, f64: Reflect, Duration: Reflect, f32: Reflect,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Resource for Timewhere Time: Send + Sync + 'static,