mirror of
https://github.com/bevyengine/bevy
synced 2024-11-26 06:30:19 +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.
62 lines
2.3 KiB
Rust
62 lines
2.3 KiB
Rust
//! This example shows how you can know when a `Component` has been removed, so you can react to it.
|
|
|
|
use bevy::prelude::*;
|
|
|
|
fn main() {
|
|
// Information regarding removed `Component`s is discarded at the end of each frame, so you need
|
|
// to react to the removal before the frame is over.
|
|
//
|
|
// Also, `Components` are removed via a `Command`. `Command`s are applied after a stage has
|
|
// finished executing. So you need to react to the removal at some stage after the
|
|
// `Component` is removed.
|
|
//
|
|
// With these constraints in mind we make sure to place the system that removes a `Component` on
|
|
// the `CoreStage::Update' stage, and the system that reacts on the removal on the
|
|
// `CoreStage::PostUpdate` stage.
|
|
App::new()
|
|
.add_plugins(DefaultPlugins)
|
|
.add_startup_system(setup)
|
|
.add_system_to_stage(CoreStage::Update, remove_component)
|
|
.add_system_to_stage(CoreStage::PostUpdate, react_on_removal)
|
|
.run();
|
|
}
|
|
|
|
// This `Struct` is just used for convenience in this example. This is the `Component` we'll be
|
|
// giving to the `Entity` so we have a `Component` to remove in `remove_component()`.
|
|
#[derive(Component)]
|
|
struct MyComponent;
|
|
|
|
fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
|
|
commands.spawn(Camera2dBundle::default());
|
|
commands.spawn((
|
|
SpriteBundle {
|
|
texture: asset_server.load("branding/icon.png"),
|
|
..default()
|
|
},
|
|
// Add the `Component`.
|
|
MyComponent,
|
|
));
|
|
}
|
|
|
|
fn remove_component(
|
|
time: Res<Time>,
|
|
mut commands: Commands,
|
|
query: Query<Entity, With<MyComponent>>,
|
|
) {
|
|
// After two seconds have passed the `Component` is removed.
|
|
if time.elapsed_seconds() > 2.0 {
|
|
if let Some(entity) = query.iter().next() {
|
|
commands.entity(entity).remove::<MyComponent>();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn react_on_removal(removed: RemovedComponents<MyComponent>, mut query: Query<&mut Sprite>) {
|
|
// `RemovedComponents<T>::iter()` returns an interator with the `Entity`s that had their
|
|
// `Component` `T` (in this case `MyComponent`) removed at some point earlier during the frame.
|
|
for entity in removed.iter() {
|
|
if let Ok(mut sprite) = query.get_mut(entity) {
|
|
sprite.color.set_r(0.0);
|
|
}
|
|
}
|
|
}
|