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.
68 lines
2.0 KiB
Rust
68 lines
2.0 KiB
Rust
use crate::{
|
|
extract_resource::ExtractResource,
|
|
render_resource::{ShaderType, UniformBuffer},
|
|
renderer::{RenderDevice, RenderQueue},
|
|
Extract, RenderApp, RenderStage,
|
|
};
|
|
use bevy_app::{App, Plugin};
|
|
use bevy_core::FrameCount;
|
|
use bevy_ecs::prelude::*;
|
|
use bevy_reflect::Reflect;
|
|
use bevy_time::Time;
|
|
|
|
pub struct GlobalsPlugin;
|
|
|
|
impl Plugin for GlobalsPlugin {
|
|
fn build(&self, app: &mut App) {
|
|
if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
|
|
render_app
|
|
.init_resource::<GlobalsBuffer>()
|
|
.init_resource::<Time>()
|
|
.add_system_to_stage(RenderStage::Extract, extract_time)
|
|
.add_system_to_stage(RenderStage::Prepare, prepare_globals_buffer);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn extract_time(mut commands: Commands, time: Extract<Res<Time>>) {
|
|
commands.insert_resource(time.clone());
|
|
}
|
|
|
|
/// Contains global values useful when writing shaders.
|
|
/// Currently only contains values related to time.
|
|
#[derive(Default, Clone, Resource, ExtractResource, Reflect, ShaderType)]
|
|
#[reflect(Resource)]
|
|
pub struct GlobalsUniform {
|
|
/// The time since startup in seconds.
|
|
/// Wraps to 0 after 1 hour.
|
|
time: f32,
|
|
/// The delta time since the previous frame in seconds
|
|
delta_time: f32,
|
|
/// Frame count since the start of the app.
|
|
/// It wraps to zero when it reaches the maximum value of a u32.
|
|
frame_count: u32,
|
|
}
|
|
|
|
/// The buffer containing the [`GlobalsUniform`]
|
|
#[derive(Resource, Default)]
|
|
pub struct GlobalsBuffer {
|
|
pub buffer: UniformBuffer<GlobalsUniform>,
|
|
}
|
|
|
|
fn prepare_globals_buffer(
|
|
render_device: Res<RenderDevice>,
|
|
render_queue: Res<RenderQueue>,
|
|
mut globals_buffer: ResMut<GlobalsBuffer>,
|
|
time: Res<Time>,
|
|
frame_count: Res<FrameCount>,
|
|
) {
|
|
let buffer = globals_buffer.buffer.get_mut();
|
|
buffer.time = time.elapsed_seconds_wrapped();
|
|
buffer.delta_time = time.delta_seconds();
|
|
buffer.frame_count = frame_count.0;
|
|
|
|
globals_buffer
|
|
.buffer
|
|
.write_buffer(&render_device, &render_queue);
|
|
}
|