mirror of
https://github.com/bevyengine/bevy
synced 2024-11-23 05:03:47 +00:00
7989cb2650
# Objective - Make `Time` API more consistent. - Support time accel/decel/pause. ## Solution This is just the `Time` half of #3002. I was told that part isn't controversial. - Give the "delta time" and "total elapsed time" methods `f32`, `f64`, and `Duration` variants with consistent naming. - Implement accelerating / decelerating the passage of time. - Implement stopping time. --- ## Changelog - Changed `time_since_startup` to `elapsed` because `time.time_*` is just silly. - Added `relative_speed` and `set_relative_speed` methods. - Added `is_paused`, `pause`, `unpause` , and methods. (I'd prefer `resume`, but `unpause` matches `Timer` API.) - Added `raw_*` variants of the "delta time" and "total elapsed time" methods. - Added `first_update` method because there's a non-zero duration between startup and the first update. ## Migration Guide - `time.time_since_startup()` -> `time.elapsed()` - `time.seconds_since_startup()` -> `time.elapsed_seconds_f64()` - `time.seconds_since_startup_wrapped_f32()` -> `time.elapsed_seconds_wrapped()` If you aren't sure which to use, most systems should continue to use "scaled" time (e.g. `time.delta_seconds()`). The realtime "unscaled" time measurements (e.g. `time.raw_delta_seconds()`) are mostly for debugging and profiling.
60 lines
1.8 KiB
Rust
60 lines
1.8 KiB
Rust
//! Shows how to create systems that run every fixed timestep, rather than every tick.
|
|
|
|
use bevy::{
|
|
prelude::*,
|
|
time::{FixedTimestep, FixedTimesteps},
|
|
};
|
|
|
|
const LABEL: &str = "my_fixed_timestep";
|
|
|
|
#[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
|
|
struct FixedUpdateStage;
|
|
|
|
fn main() {
|
|
App::new()
|
|
.add_plugins(DefaultPlugins)
|
|
// this system will run once every update (it should match your screen's refresh rate)
|
|
.add_system(frame_update)
|
|
// add a new stage that runs twice a second
|
|
.add_stage_after(
|
|
CoreStage::Update,
|
|
FixedUpdateStage,
|
|
SystemStage::parallel()
|
|
.with_run_criteria(
|
|
FixedTimestep::step(0.5)
|
|
// labels are optional. they provide a way to access the current
|
|
// FixedTimestep state from within a system
|
|
.with_label(LABEL),
|
|
)
|
|
.with_system(fixed_update),
|
|
)
|
|
.run();
|
|
}
|
|
|
|
fn frame_update(mut last_time: Local<f32>, time: Res<Time>) {
|
|
info!(
|
|
"time since last frame_update: {}",
|
|
time.raw_elapsed_seconds() - *last_time
|
|
);
|
|
*last_time = time.raw_elapsed_seconds();
|
|
}
|
|
|
|
fn fixed_update(mut last_time: Local<f32>, time: Res<Time>, fixed_timesteps: Res<FixedTimesteps>) {
|
|
info!(
|
|
"time since last fixed_update: {}\n",
|
|
time.raw_elapsed_seconds() - *last_time
|
|
);
|
|
|
|
let state = fixed_timesteps.get(LABEL).unwrap();
|
|
|
|
info!("fixed timestep: {}\n", 0.5);
|
|
info!(
|
|
"time accrued toward next fixed_update: {}\n",
|
|
state.accumulator()
|
|
);
|
|
info!(
|
|
"time accrued toward next fixed_update (% of timestep): {}",
|
|
state.overstep_percentage()
|
|
);
|
|
*last_time = time.raw_elapsed_seconds();
|
|
}
|