bevy_render/
globals.rs

1use crate::{
2    extract_resource::ExtractResource,
3    prelude::Shader,
4    render_resource::{ShaderType, UniformBuffer},
5    renderer::{RenderDevice, RenderQueue},
6    Extract, ExtractSchedule, Render, RenderApp, RenderSet,
7};
8use bevy_app::{App, Plugin};
9use bevy_asset::{load_internal_asset, Handle};
10use bevy_core::FrameCount;
11use bevy_ecs::prelude::*;
12use bevy_reflect::prelude::*;
13use bevy_time::Time;
14
15pub const GLOBALS_TYPE_HANDLE: Handle<Shader> = Handle::weak_from_u128(17924628719070609599);
16
17pub struct GlobalsPlugin;
18
19impl Plugin for GlobalsPlugin {
20    fn build(&self, app: &mut App) {
21        load_internal_asset!(app, GLOBALS_TYPE_HANDLE, "globals.wgsl", Shader::from_wgsl);
22        app.register_type::<GlobalsUniform>();
23
24        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
25            render_app
26                .init_resource::<GlobalsBuffer>()
27                .init_resource::<Time>()
28                .add_systems(ExtractSchedule, (extract_frame_count, extract_time))
29                .add_systems(
30                    Render,
31                    prepare_globals_buffer.in_set(RenderSet::PrepareResources),
32                );
33        }
34    }
35}
36
37fn extract_frame_count(mut commands: Commands, frame_count: Extract<Res<FrameCount>>) {
38    commands.insert_resource(**frame_count);
39}
40
41fn extract_time(mut commands: Commands, time: Extract<Res<Time>>) {
42    commands.insert_resource(**time);
43}
44
45/// Contains global values useful when writing shaders.
46/// Currently only contains values related to time.
47#[derive(Default, Clone, Resource, ExtractResource, Reflect, ShaderType)]
48#[reflect(Resource, Default)]
49pub struct GlobalsUniform {
50    /// The time since startup in seconds.
51    /// Wraps to 0 after 1 hour.
52    time: f32,
53    /// The delta time since the previous frame in seconds
54    delta_time: f32,
55    /// Frame count since the start of the app.
56    /// It wraps to zero when it reaches the maximum value of a u32.
57    frame_count: u32,
58    /// WebGL2 structs must be 16 byte aligned.
59    #[cfg(all(feature = "webgl", target_arch = "wasm32", not(feature = "webgpu")))]
60    _wasm_padding: f32,
61}
62
63/// The buffer containing the [`GlobalsUniform`]
64#[derive(Resource, Default)]
65pub struct GlobalsBuffer {
66    pub buffer: UniformBuffer<GlobalsUniform>,
67}
68
69fn prepare_globals_buffer(
70    render_device: Res<RenderDevice>,
71    render_queue: Res<RenderQueue>,
72    mut globals_buffer: ResMut<GlobalsBuffer>,
73    time: Res<Time>,
74    frame_count: Res<FrameCount>,
75) {
76    let buffer = globals_buffer.buffer.get_mut();
77    buffer.time = time.elapsed_secs_wrapped();
78    buffer.delta_time = time.delta_secs();
79    buffer.frame_count = frame_count.0;
80
81    globals_buffer
82        .buffer
83        .write_buffer(&render_device, &render_queue);
84}