From 1441afd6db7f2de685a6f9443aae41ff02e358db Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 31 Mar 2022 10:28:24 -0700
Subject: [PATCH] fix examples

---
 examples/2d/rotation.rs                     | 16 ++++---
 examples/2d/text2d.rs                       |  8 ++--
 examples/3d/manual_gltf_animation_player.rs | 12 +++--
 examples/3d/update_gltf_scene.rs            | 12 ++---
 examples/animation/custom_skinned_mesh.rs   |  2 +-
 examples/animation/gltf_skinned_mesh.rs     |  2 +-
 examples/ecs/component_change_detection.rs  |  2 +-
 examples/ecs/fixed_timestep.rs              | 50 ++++++++++++---------
 examples/ecs/iter_combinations.rs           | 19 +++++---
 examples/game/alien_cake_addict.rs          |  9 +++-
 examples/game/breakout.rs                   | 17 ++++---
 examples/scene/scene.rs                     |  4 +-
 examples/tools/bevymark.rs                  |  2 +-
 examples/ui/text.rs                         |  2 +-
 examples/ui/text_debug.rs                   |  2 +-
 15 files changed, 98 insertions(+), 61 deletions(-)

diff --git a/examples/2d/rotation.rs b/examples/2d/rotation.rs
index 8ab5b7fd32050..f6912a0ab1044 100644
--- a/examples/2d/rotation.rs
+++ b/examples/2d/rotation.rs
@@ -13,7 +13,7 @@ fn main() {
         .add_startup_system(setup)
         .add_system_set(
             SystemSet::new()
-                .with_run_criteria(FixedTimestep::step(TIME_STEP as f64))
+                .with_run_criteria(FixedTimestep::step)
                 .with_system(player_movement_system)
                 .with_system(snap_to_player_system)
                 .with_system(rotate_to_player_system),
@@ -51,7 +51,9 @@ struct RotateToPlayer {
 /// * Z axis goes from far to near (+Z points towards you, out of the screen)
 ///
 /// The origin is at the center of the screen.
-fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+fn setup(mut commands: Commands, mut time: ResMut<FixedTime>, asset_server: Res<AssetServer>) {
+    time.set_delta_seconds(TIME_STEP);
+
     let ship_handle = asset_server.load("textures/simplespace/ship_C.png");
     let enemy_a_handle = asset_server.load("textures/simplespace/enemy_A.png");
     let enemy_b_handle = asset_server.load("textures/simplespace/enemy_B.png");
@@ -112,6 +114,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 
 /// Demonstrates applying rotation and movement based on keyboard input.
 fn player_movement_system(
+    time: Res<FixedTime>,
     keyboard_input: Res<Input<KeyCode>>,
     mut query: Query<(&Player, &mut Transform)>,
 ) {
@@ -133,14 +136,15 @@ fn player_movement_system(
     }
 
     // create the change in rotation around the Z axis (perpendicular to the 2D plane of the screen)
-    let rotation_delta = Quat::from_rotation_z(rotation_factor * ship.rotation_speed * TIME_STEP);
+    let rotation_delta =
+        Quat::from_rotation_z(rotation_factor * ship.rotation_speed * time.delta_seconds());
     // update the ship rotation with our rotation delta
     transform.rotation *= rotation_delta;
 
     // get the ship's forward vector by applying the current rotation to the ships initial facing vector
     let movement_direction = transform.rotation * Vec3::Y;
     // get the distance the ship will move based on direction, the ship's movement speed and delta time
-    let movement_distance = movement_factor * ship.movement_speed * TIME_STEP;
+    let movement_distance = movement_factor * ship.movement_speed * time.delta_seconds();
     // create the change in translation using the new movement direction and distance
     let translation_delta = movement_direction * movement_distance;
     // update the ship translation with our new translation delta
@@ -195,6 +199,7 @@ fn snap_to_player_system(
 /// floating point precision loss, so it pays to clamp your dot product value before calling
 /// `acos`.
 fn rotate_to_player_system(
+    time: Res<FixedTime>,
     mut query: Query<(&RotateToPlayer, &mut Transform), Without<Player>>,
     player_query: Query<&Transform, With<Player>>,
 ) {
@@ -239,7 +244,8 @@ fn rotate_to_player_system(
         let max_angle = forward_dot_player.clamp(-1.0, 1.0).acos(); // clamp acos for safety
 
         // calculate angle of rotation with limit
-        let rotation_angle = rotation_sign * (config.rotation_speed * TIME_STEP).min(max_angle);
+        let rotation_angle =
+            rotation_sign * (config.rotation_speed * time.delta_seconds()).min(max_angle);
 
         // get the quaternion to rotate from the current enemy facing direction towards the
         // direction facing the player
diff --git a/examples/2d/text2d.rs b/examples/2d/text2d.rs
index 9a41e7912c246..10352bc694828 100644
--- a/examples/2d/text2d.rs
+++ b/examples/2d/text2d.rs
@@ -94,8 +94,8 @@ fn animate_translation(
     mut query: Query<&mut Transform, (With<Text>, With<AnimateTranslation>)>,
 ) {
     for mut transform in query.iter_mut() {
-        transform.translation.x = 100.0 * time.seconds_since_startup().sin() as f32 - 400.0;
-        transform.translation.y = 100.0 * time.seconds_since_startup().cos() as f32;
+        transform.translation.x = 100.0 * time.seconds_since_startup().sin() - 400.0;
+        transform.translation.y = 100.0 * time.seconds_since_startup().cos();
     }
 }
 
@@ -104,7 +104,7 @@ fn animate_rotation(
     mut query: Query<&mut Transform, (With<Text>, With<AnimateRotation>)>,
 ) {
     for mut transform in query.iter_mut() {
-        transform.rotation = Quat::from_rotation_z(time.seconds_since_startup().cos() as f32);
+        transform.rotation = Quat::from_rotation_z(time.seconds_since_startup().cos());
     }
 }
 
@@ -116,6 +116,6 @@ fn animate_scale(
     // rendered quad, resulting in a pixellated look.
     for mut transform in query.iter_mut() {
         transform.translation = Vec3::new(400.0, 0.0, 0.0);
-        transform.scale = Vec3::splat((time.seconds_since_startup().sin() as f32 + 1.1) * 2.0);
+        transform.scale = Vec3::splat((time.seconds_since_startup().sin() + 1.1) * 2.0);
     }
 }
diff --git a/examples/3d/manual_gltf_animation_player.rs b/examples/3d/manual_gltf_animation_player.rs
index efd4b03210a7a..14534715052e7 100644
--- a/examples/3d/manual_gltf_animation_player.rs
+++ b/examples/3d/manual_gltf_animation_player.rs
@@ -19,7 +19,7 @@ fn main() {
         .add_startup_system(setup)
         .add_system_set(
             SystemSet::new()
-                .with_run_criteria(FixedTimestep::step(10.0))
+                .with_run_criteria(FixedTimestep::step)
                 .with_system(switch_scene),
         )
         .add_system(setup_scene_once_loaded)
@@ -82,15 +82,19 @@ struct CurrentScene {
 }
 
 struct CurrentAnimation {
-    start_time: f64,
+    start_time: f32,
     animation: GltfAnimation,
 }
 
 fn setup(
     mut commands: Commands,
+    mut time: ResMut<FixedTime>,
     asset_server: Res<AssetServer>,
     mut scene_spawner: ResMut<SceneSpawner>,
 ) {
+    // Fixed timestep
+    time.set_delta_seconds(10.0);
+
     // Insert a resource with the current scene information
     commands.insert_resource(CurrentScene {
         // Its instance id, to be able to check that it's loaded
@@ -174,8 +178,8 @@ fn gltf_animation_driver(
     time: Res<Time>,
 ) {
     if let Some(current_animation) = current_animation {
-        let elapsed = (time.seconds_since_startup() - current_animation.start_time) as f32
-            * current_scene.speed;
+        let elapsed =
+            (time.seconds_since_startup() - current_animation.start_time) * current_scene.speed;
         for (mut transform, node) in animated.iter_mut() {
             let node_animations = current_animation
                 .animation
diff --git a/examples/3d/update_gltf_scene.rs b/examples/3d/update_gltf_scene.rs
index 3a23e82028ab1..b5834921bc72e 100644
--- a/examples/3d/update_gltf_scene.rs
+++ b/examples/3d/update_gltf_scene.rs
@@ -76,15 +76,15 @@ fn move_scene_entities(
     time: Res<Time>,
     mut scene_entities: Query<&mut Transform, With<EntityInMyScene>>,
 ) {
-    let mut direction = 1.;
-    let mut scale = 1.;
+    let mut direction = 1.0;
+    let mut scale = 1.0;
     for mut transform in scene_entities.iter_mut() {
         transform.translation = Vec3::new(
-            scale * direction * time.seconds_since_startup().sin() as f32 / 20.,
-            0.,
-            time.seconds_since_startup().cos() as f32 / 20.,
+            scale * direction * time.seconds_since_startup().sin() / 20.0,
+            0.0,
+            time.seconds_since_startup().cos() / 20.0,
         );
-        direction *= -1.;
+        direction *= -1.0;
         scale += 0.5;
     }
 }
diff --git a/examples/animation/custom_skinned_mesh.rs b/examples/animation/custom_skinned_mesh.rs
index 5216cd08a65de..38c558f624dee 100644
--- a/examples/animation/custom_skinned_mesh.rs
+++ b/examples/animation/custom_skinned_mesh.rs
@@ -165,7 +165,7 @@ fn joint_animation(time: Res<Time>, mut query: Query<&mut Transform, With<Animat
     for mut transform in query.iter_mut() {
         transform.rotation = Quat::from_axis_angle(
             Vec3::Z,
-            0.5 * PI * time.time_since_startup().as_secs_f32().sin(),
+            0.5 * PI * time.seconds_since_startup().sin(),
         );
     }
 }
diff --git a/examples/animation/gltf_skinned_mesh.rs b/examples/animation/gltf_skinned_mesh.rs
index ba318e2256131..ba61477e0cb4d 100644
--- a/examples/animation/gltf_skinned_mesh.rs
+++ b/examples/animation/gltf_skinned_mesh.rs
@@ -64,7 +64,7 @@ fn joint_animation(
 
         second_joint_transform.rotation = Quat::from_axis_angle(
             Vec3::Z,
-            0.5 * PI * time.time_since_startup().as_secs_f32().sin(),
+            0.5 * PI * time.seconds_since_startup().sin(),
         );
     }
 }
diff --git a/examples/ecs/component_change_detection.rs b/examples/ecs/component_change_detection.rs
index 01473c7749bc0..9ca065cd61a18 100644
--- a/examples/ecs/component_change_detection.rs
+++ b/examples/ecs/component_change_detection.rs
@@ -13,7 +13,7 @@ fn main() {
 }
 
 #[derive(Component, Debug)]
-struct MyComponent(f64);
+struct MyComponent(f32);
 
 fn setup(mut commands: Commands) {
     commands.spawn().insert(MyComponent(0.));
diff --git a/examples/ecs/fixed_timestep.rs b/examples/ecs/fixed_timestep.rs
index f89d3046689ee..be9b3c82eeb17 100644
--- a/examples/ecs/fixed_timestep.rs
+++ b/examples/ecs/fixed_timestep.rs
@@ -1,50 +1,58 @@
 use bevy::{
-    core::{FixedTimestep, FixedTimesteps},
+    core::{FixedTimestep, FixedTimestepState},
     prelude::*,
 };
 
-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_startup_system(set_fixed_timestep)
+        // This system will run once every update.
         .add_system(frame_update)
-        // add a new stage that runs twice a second
+        // This stage will run ten times 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_run_criteria(FixedTimestep::step)
                 .with_system(fixed_update),
         )
         .run();
 }
 
-fn frame_update(mut last_time: Local<f64>, time: Res<Time>) {
-    info!("update: {}", time.seconds_since_startup() - *last_time);
-    *last_time = time.seconds_since_startup();
+fn set_fixed_timestep(mut time: ResMut<FixedTime>) {
+    time.set_steps_per_second(10.0);
 }
 
-fn fixed_update(mut last_time: Local<f64>, time: Res<Time>, fixed_timesteps: Res<FixedTimesteps>) {
+fn frame_update(mut last_time: Local<f32>, time: Res<Time>) {
     info!(
-        "fixed_update: {}",
-        time.seconds_since_startup() - *last_time,
+        "time since last frame_update: {}",
+        time.seconds_since_startup() - *last_time
     );
+    *last_time = time.seconds_since_startup();
+}
 
-    let fixed_timestep = fixed_timesteps.get(LABEL).unwrap();
+fn fixed_update(
+    mut last_time: Local<f32>,
+    time: Res<Time>,
+    fixed_time: Res<FixedTime>,
+    accumulator: Res<FixedTimestepState>,
+) {
     info!(
-        "  overstep_percentage: {}",
-        fixed_timestep.overstep_percentage()
+        "time since last fixed_update: {}\n",
+        time.seconds_since_startup() - *last_time
+    );
+    info!("fixed timestep: {}\n", fixed_time.delta_seconds());
+    info!(
+        "time accrued toward next fixed_update: {}\n",
+        accumulator.overstep().as_secs_f32()
+    );
+    info!(
+        "time accrued toward next fixed_update (% of timestep): {}",
+        accumulator.overstep_percentage(fixed_time.delta())
     );
-
     *last_time = time.seconds_since_startup();
 }
diff --git a/examples/ecs/iter_combinations.rs b/examples/ecs/iter_combinations.rs
index e4122f17f7cae..3475b6d40f172 100644
--- a/examples/ecs/iter_combinations.rs
+++ b/examples/ecs/iter_combinations.rs
@@ -4,7 +4,7 @@ use rand::{thread_rng, Rng};
 #[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
 struct FixedUpdateStage;
 
-const DELTA_TIME: f64 = 0.01;
+const TIME_STEP: f32 = 0.01;
 
 fn main() {
     App::new()
@@ -14,12 +14,13 @@ fn main() {
             brightness: 0.03,
             ..default()
         })
+        .add_startup_system(setup_fixed_timestep)
         .add_startup_system(generate_bodies)
         .add_stage_after(
             CoreStage::Update,
             FixedUpdateStage,
             SystemStage::parallel()
-                .with_run_criteria(FixedTimestep::step(DELTA_TIME))
+                .with_run_criteria(FixedTimestep::step)
                 .with_system(interact_bodies)
                 .with_system(integrate),
         )
@@ -49,8 +50,13 @@ struct BodyBundle {
     acceleration: Acceleration,
 }
 
+fn setup_fixed_timestep(mut time: ResMut<FixedTime>) {
+    time.set_delta_seconds(TIME_STEP);
+}
+
 fn generate_bodies(
     mut commands: Commands,
+    time: Res<FixedTime>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
@@ -102,7 +108,7 @@ fn generate_bodies(
                         rng.gen_range(vel_range.clone()),
                         rng.gen_range(vel_range.clone()),
                         rng.gen_range(vel_range.clone()),
-                    ) * DELTA_TIME as f32,
+                    ) * time.delta_seconds(),
             ),
         });
     }
@@ -161,8 +167,11 @@ fn interact_bodies(mut query: Query<(&Mass, &GlobalTransform, &mut Acceleration)
     }
 }
 
-fn integrate(mut query: Query<(&mut Acceleration, &mut Transform, &mut LastPos)>) {
-    let dt_sq = (DELTA_TIME * DELTA_TIME) as f32;
+fn integrate(
+    time: Res<FixedTime>,
+    mut query: Query<(&mut Acceleration, &mut Transform, &mut LastPos)>,
+) {
+    let dt_sq = time.delta_seconds() * time.delta_seconds();
     for (mut acceleration, mut transform, mut last_pos) in query.iter_mut() {
         // verlet integration
         // x(t+dt) = 2x(t) - x(t-dt) + a(t)dt^2 + O(dt^4)
diff --git a/examples/game/alien_cake_addict.rs b/examples/game/alien_cake_addict.rs
index 17b9fad43c975..3c02c9dc6d04c 100644
--- a/examples/game/alien_cake_addict.rs
+++ b/examples/game/alien_cake_addict.rs
@@ -13,6 +13,7 @@ fn main() {
         .init_resource::<Game>()
         .add_plugins(DefaultPlugins)
         .add_state(GameState::Playing)
+        .add_startup_system(setup_fixed_timestep)
         .add_startup_system(setup_cameras)
         .add_system_set(SystemSet::on_enter(GameState::Playing).with_system(setup))
         .add_system_set(
@@ -28,7 +29,7 @@ fn main() {
         .add_system_set(SystemSet::on_exit(GameState::GameOver).with_system(teardown))
         .add_system_set(
             SystemSet::new()
-                .with_run_criteria(FixedTimestep::step(5.0))
+                .with_run_criteria(FixedTimestep::step)
                 .with_system(spawn_bonus),
         )
         .add_system(bevy::input::system::exit_on_esc_system)
@@ -75,6 +76,10 @@ const RESET_FOCUS: [f32; 3] = [
     BOARD_SIZE_J as f32 / 2.0 - 0.5,
 ];
 
+fn setup_fixed_timestep(mut time: ResMut<FixedTime>) {
+    time.set_delta_seconds(5.0);
+}
+
 fn setup_cameras(mut commands: Commands, mut game: ResMut<Game>) {
     game.camera_should_focus = Vec3::from(RESET_FOCUS);
     game.camera_is_focus = game.camera_should_focus;
@@ -350,7 +355,7 @@ fn rotate_bonus(game: Res<Game>, time: Res<Time>, mut transforms: Query<&mut Tra
         if let Ok(mut cake_transform) = transforms.get_mut(entity) {
             cake_transform.rotate(Quat::from_rotation_y(time.delta_seconds()));
             cake_transform.scale = Vec3::splat(
-                1.0 + (game.score as f32 / 10.0 * time.seconds_since_startup().sin() as f32).abs(),
+                1.0 + (game.score as f32 / 10.0 * time.seconds_since_startup().sin()).abs(),
             );
         }
     }
diff --git a/examples/game/breakout.rs b/examples/game/breakout.rs
index d00e5200df6ad..3ced801a00692 100644
--- a/examples/game/breakout.rs
+++ b/examples/game/breakout.rs
@@ -60,7 +60,7 @@ fn main() {
         .add_startup_system(setup)
         .add_system_set(
             SystemSet::new()
-                .with_run_criteria(FixedTimestep::step(TIME_STEP as f64))
+                .with_run_criteria(FixedTimestep::step)
                 .with_system(check_for_collisions)
                 .with_system(move_paddle.before(check_for_collisions))
                 .with_system(apply_velocity.before(check_for_collisions)),
@@ -162,7 +162,10 @@ struct Scoreboard {
 }
 
 // Add the game's entities to our world
-fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+fn setup(mut commands: Commands, mut time: ResMut<FixedTime>, asset_server: Res<AssetServer>) {
+    // FixedTimestep
+    time.set_delta_seconds(TIME_STEP);
+
     // Cameras
     commands.spawn_bundle(OrthographicCameraBundle::new_2d());
     commands.spawn_bundle(UiCameraBundle::default());
@@ -308,6 +311,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 
 fn move_paddle(
     keyboard_input: Res<Input<KeyCode>>,
+    time: Res<FixedTime>,
     mut query: Query<&mut Transform, With<Paddle>>,
 ) {
     let mut paddle_transform = query.single_mut();
@@ -322,7 +326,8 @@ fn move_paddle(
     }
 
     // Calculate the new horizontal paddle position based on player input
-    let new_paddle_position = paddle_transform.translation.x + direction * PADDLE_SPEED * TIME_STEP;
+    let new_paddle_position =
+        paddle_transform.translation.x + direction * PADDLE_SPEED * time.delta_seconds();
 
     // Update the paddle position,
     // making sure it doesn't cause the paddle to leave the arena
@@ -332,10 +337,10 @@ fn move_paddle(
     paddle_transform.translation.x = new_paddle_position.clamp(left_bound, right_bound);
 }
 
-fn apply_velocity(mut query: Query<(&mut Transform, &Velocity)>) {
+fn apply_velocity(time: Res<FixedTime>, mut query: Query<(&mut Transform, &Velocity)>) {
     for (mut transform, velocity) in query.iter_mut() {
-        transform.translation.x += velocity.x * TIME_STEP;
-        transform.translation.y += velocity.y * TIME_STEP;
+        transform.translation.x += velocity.x * time.delta_seconds();
+        transform.translation.y += velocity.y * time.delta_seconds();
     }
 }
 
diff --git a/examples/scene/scene.rs b/examples/scene/scene.rs
index e7b566dc1332b..e2f1624cfe6c5 100644
--- a/examples/scene/scene.rs
+++ b/examples/scene/scene.rs
@@ -35,14 +35,14 @@ struct ComponentA {
 struct ComponentB {
     pub value: String,
     #[reflect(ignore)]
-    pub _time_since_startup: Duration,
+    pub _elapsed_since_startup: Duration,
 }
 
 impl FromWorld for ComponentB {
     fn from_world(world: &mut World) -> Self {
         let time = world.resource::<Time>();
         ComponentB {
-            _time_since_startup: time.time_since_startup(),
+            _elapsed_since_startup: time.elapsed_since_startup(),
             value: "Default Value".to_string(),
         }
     }
diff --git a/examples/tools/bevymark.rs b/examples/tools/bevymark.rs
index ad2e5a6cb09d9..6600f24394587 100644
--- a/examples/tools/bevymark.rs
+++ b/examples/tools/bevymark.rs
@@ -49,7 +49,7 @@ fn main() {
         .add_system(counter_system)
         .add_system_set(
             SystemSet::new()
-                .with_run_criteria(FixedTimestep::step(0.2))
+                .with_run_criteria(FixedTimestep::step)
                 .with_system(scheduled_spawner),
         )
         .run();
diff --git a/examples/ui/text.rs b/examples/ui/text.rs
index bd257cd78f2e2..ca92acd7d20d6 100644
--- a/examples/ui/text.rs
+++ b/examples/ui/text.rs
@@ -106,7 +106,7 @@ fn text_update_system(diagnostics: Res<Diagnostics>, mut query: Query<&mut Text,
 
 fn text_color_system(time: Res<Time>, mut query: Query<&mut Text, With<ColorText>>) {
     for mut text in query.iter_mut() {
-        let seconds = time.seconds_since_startup() as f32;
+        let seconds = time.seconds_since_startup();
         // We used the `Text::with_section` helper method, but it is still just a `Text`,
         // so to update it, we are still updating the one and only section
         text.sections[0].style.color = Color::Rgba {
diff --git a/examples/ui/text_debug.rs b/examples/ui/text_debug.rs
index 1709cf7175b5e..2f01c7203da74 100644
--- a/examples/ui/text_debug.rs
+++ b/examples/ui/text_debug.rs
@@ -184,7 +184,7 @@ fn change_text_system(
             }
         }
 
-        let mut frame_time = time.delta_seconds_f64();
+        let mut frame_time = time.raw_delta_seconds_f64();
         if let Some(frame_time_diagnostic) = diagnostics.get(FrameTimeDiagnosticsPlugin::FRAME_TIME)
         {
             if let Some(frame_time_avg) = frame_time_diagnostic.average() {