Struct bones_lib::time::Time

#[repr(C)]
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) -> Self

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 bones rendering backend.

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 whatever bones renderer you are using.

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 advance_exact(&mut self, duration: Duration)

Advance the time exactly by the given duration.

This is useful when ticking the time exactly by a fixed timestep.

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 pause(&mut self)

Stops the clock, preventing it from advancing until resumed.

Note: This does 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

Formats the value using the given formatter.

impl Default for Time

fn default() -> Self

Returns the “default value” for a type.

impl HasSchema for Time

fn schema() -> &'static Schema

Get this type’s [Schema].

fn register_schema()

Register this schema with the global schema registry.

fn cast<T>(this: &Self) -> &T

where T: HasSchema,

Cast a reference of this type to a reference of another type with the same memory layout.

fn try_cast<T>(this: &Self) -> Result<&T, SchemaMismatchError>

where T: HasSchema,

Cast a reference of this type to a reference of another type with the same memory layout.

fn cast_mut<T>(this: &mut Self) -> &mut T

where T: HasSchema,

Cast a mutable reference of this type to a reference of another type with the same memory layout.

fn try_cast_mut<T>(this: &mut Self) -> Result<&mut T, SchemaMismatchError>

where T: HasSchema,

Cast a mutable reference of this type to a reference of another type with the same memory layout.

fn as_schema_ref(&self) -> SchemaRef<'_>

where Self: Sized,

Converts a reference of T to a SchemaRef

fn as_schema_mut(&mut self) -> SchemaRefMut<'_>

where Self: Sized,

Converts a reference of T to a SchemaRefMut

impl Copy for Time