[Merged by Bors] - add globals to mesh view bind group

assets/shaders/animate_shader.wgsl

@@ -1,39 +1,7 @@
 #import bevy_pbr::mesh_types
+// The time since startup data is in the globals binding which is part of the mesh_view_bindings import
 #import bevy_pbr::mesh_view_bindings
 
-@group(1) @binding(0)
-var<uniform> mesh: Mesh;
-
-// NOTE: Bindings must come before functions that use them!
-#import bevy_pbr::mesh_functions
-
-struct Vertex {
-    @location(0) position: vec3<f32>,
-    @location(1) normal: vec3<f32>,
-    @location(2) uv: vec2<f32>,
-};
-
-struct VertexOutput {
-    @builtin(position) clip_position: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-};
-
-@vertex
-fn vertex(vertex: Vertex) -> VertexOutput {
-    var out: VertexOutput;
-    out.clip_position = mesh_position_local_to_clip(mesh.model, vec4<f32>(vertex.position, 1.0));
-    out.uv = vertex.uv;
-    return out;
-}
-
-
-struct Time {
-    time_since_startup: f32,
-};
-@group(2) @binding(0)
-var<uniform> time: Time;
-
-
 fn oklab_to_linear_srgb(c: vec3<f32>) -> vec3<f32> {
     let L = c.x;
     let a = c.y;
@@ -43,22 +11,28 @@ fn oklab_to_linear_srgb(c: vec3<f32>) -> vec3<f32> {
     let m_ = L - 0.1055613458 * a - 0.0638541728 * b;
     let s_ = L - 0.0894841775 * a - 1.2914855480 * b;
 
-    let l = l_*l_*l_;
-    let m = m_*m_*m_;
-    let s = s_*s_*s_;
+    let l = l_ * l_ * l_;
+    let m = m_ * m_ * m_;
+    let s = s_ * s_ * s_;
 
     return vec3<f32>(
-		 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
-		-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
-		-0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s,
+        4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+        -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+        -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s,
     );
 }
 
+struct FragmentInput {
+    #import bevy_pbr::mesh_vertex_output
+}
+
 @fragment
-fn fragment(in: VertexOutput) -> @location(0) vec4<f32> {
+fn fragment(in: FragmentInput) -> @location(0) vec4<f32> {
     let speed = 2.0;
-    let t_1 = sin(time.time_since_startup * speed) * 0.5 + 0.5;
-    let t_2 = cos(time.time_since_startup * speed);
+    // The globals binding contains various global values like time
+    // which is the time since startup in seconds
+    let t_1 = sin(globals.time * speed) * 0.5 + 0.5;
+    let t_2 = cos(globals.time * speed);
 
     let distance_to_center = distance(in.uv, vec2<f32>(0.5)) * 1.4;
 

crates/bevy_core/src/lib.rs

@@ -4,6 +4,7 @@
 mod name;
 mod task_pool_options;
 
+use bevy_ecs::system::Resource;
 pub use bytemuck::{bytes_of, cast_slice, Pod, Zeroable};
 pub use name::*;
 pub use task_pool_options::*;
@@ -37,6 +38,8 @@ impl Plugin for CorePlugin {
 
         register_rust_types(app);
         register_math_types(app);
+
+        app.init_resource::<FrameCount>();
     }
 }
 
@@ -83,3 +86,9 @@ fn register_math_types(app: &mut App) {
         .register_type::<bevy_math::DQuat>()
         .register_type::<bevy_math::Quat>();
 }
+
+/// Keeps a count of rendered frames since the start of the app
+///
+/// Wraps to 0 when it reaches the maximum u32 value
+#[derive(Default, Resource, Clone, Copy)]
+pub struct FrameCount(pub u32);

crates/bevy_diagnostic/Cargo.toml

@@ -16,3 +16,4 @@ bevy_ecs = { path = "../bevy_ecs", version = "0.9.0-dev" }
 bevy_log = { path = "../bevy_log", version = "0.9.0-dev" }
 bevy_time = { path = "../bevy_time", version = "0.9.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.9.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.9.0-dev" }

crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs

@@ -1,21 +1,16 @@
 use crate::{Diagnostic, DiagnosticId, Diagnostics};
 use bevy_app::prelude::*;
-use bevy_ecs::system::{Res, ResMut, Resource};
+use bevy_core::FrameCount;
+use bevy_ecs::system::{Res, ResMut};
 use bevy_time::Time;
 
 /// Adds "frame time" diagnostic to an App, specifically "frame time", "fps" and "frame count"
 #[derive(Default)]
 pub struct FrameTimeDiagnosticsPlugin;
 
-#[derive(Resource)]
-pub struct FrameTimeDiagnosticsState {
-    frame_count: u64,
-}
-
 impl Plugin for FrameTimeDiagnosticsPlugin {
     fn build(&self, app: &mut bevy_app::App) {
         app.add_startup_system(Self::setup_system)
-            .insert_resource(FrameTimeDiagnosticsState { frame_count: 0 })
             .add_system(Self::diagnostic_system);
     }
 }
@@ -36,12 +31,9 @@ impl FrameTimeDiagnosticsPlugin {
     pub fn diagnostic_system(
         mut diagnostics: ResMut<Diagnostics>,
         time: Res<Time>,
-        mut state: ResMut<FrameTimeDiagnosticsState>,
+        frame_count: Res<FrameCount>,
     ) {
-        diagnostics.add_measurement(Self::FRAME_COUNT, || {
-            state.frame_count = state.frame_count.wrapping_add(1);
-            state.frame_count as f64
-        });
+        diagnostics.add_measurement(Self::FRAME_COUNT, || frame_count.0 as f64);
 
         if time.delta_seconds_f64() == 0.0 {
             return;
@@ -52,9 +44,3 @@ impl FrameTimeDiagnosticsPlugin {
         diagnostics.add_measurement(Self::FPS, || 1.0 / time.delta_seconds_f64());
     }
 }
-
-impl FrameTimeDiagnosticsState {
-    pub fn reset_frame_count(&mut self) {
-        self.frame_count = 0;
-    }
-}

crates/bevy_pbr/src/render/mesh.rs

@@ -13,6 +13,7 @@ use bevy_math::{Mat3A, Mat4, Vec2};
 use bevy_reflect::TypeUuid;
 use bevy_render::{
     extract_component::{ComponentUniforms, DynamicUniformIndex, UniformComponentPlugin},
+    globals::{GlobalsBuffer, GlobalsUniform},
     mesh::{
         skinning::{SkinnedMesh, SkinnedMeshInverseBindposes},
         GpuBufferInfo, Mesh, MeshVertexBufferLayout,
@@ -383,6 +384,16 @@ impl FromWorld for MeshPipeline {
                     },
                     count: None,
                 },
+                BindGroupLayoutEntry {
+                    binding: 9,
+                    visibility: ShaderStages::VERTEX_FRAGMENT,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Uniform,
+                        has_dynamic_offset: false,
+                        min_binding_size: Some(GlobalsUniform::min_size()),
+                    },
+                    count: None,
+                },
             ],
             label: Some("mesh_view_layout"),
         });
@@ -469,6 +480,7 @@ impl FromWorld for MeshPipeline {
                 ),
             }
         };
+
         MeshPipeline {
             view_layout,
             mesh_layout,
@@ -764,11 +776,13 @@ pub fn queue_mesh_view_bind_groups(
     global_light_meta: Res<GlobalLightMeta>,
     view_uniforms: Res<ViewUniforms>,
     views: Query<(Entity, &ViewShadowBindings, &ViewClusterBindings)>,
+    globals_buffer: Res<GlobalsBuffer>,
 ) {
-    if let (Some(view_binding), Some(light_binding), Some(point_light_binding)) = (
+    if let (Some(view_binding), Some(light_binding), Some(point_light_binding), Some(globals)) = (
         view_uniforms.uniforms.binding(),
         light_meta.view_gpu_lights.binding(),
         global_light_meta.gpu_point_lights.binding(),
+        globals_buffer.buffer.binding(),
     ) {
         for (entity, view_shadow_bindings, view_cluster_bindings) in &views {
             let view_bind_group = render_device.create_bind_group(&BindGroupDescriptor {
@@ -815,6 +829,10 @@ pub fn queue_mesh_view_bind_groups(
                         binding: 8,
                         resource: view_cluster_bindings.offsets_and_counts_binding().unwrap(),
                     },
+                    BindGroupEntry {
+                        binding: 9,
+                        resource: globals.clone(),
+                    },
                 ],
                 label: Some("mesh_view_bind_group"),
                 layout: &mesh_pipeline.view_layout,

crates/bevy_pbr/src/render/mesh_view_bindings.wgsl

@@ -40,3 +40,6 @@ var<storage> cluster_light_index_lists: ClusterLightIndexLists;
 @group(0) @binding(8)
 var<storage> cluster_offsets_and_counts: ClusterOffsetsAndCounts;
 #endif
+
+@group(0) @binding(9)
+var<uniform> globals: Globals;

crates/bevy_pbr/src/render/mesh_view_types.wgsl

@@ -85,3 +85,14 @@ struct ClusterOffsetsAndCounts {
     data: array<vec4<u32>>,
 };
 #endif
+
+struct Globals {
+    // 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,
+}

crates/bevy_render/src/globals.rs

@@ -0,0 +1,67 @@
+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.seconds_since_startup_wrapped_f32();
+    buffer.delta_time = time.delta_seconds();
+    buffer.frame_count = frame_count.0;
+
+    globals_buffer
+        .buffer
+        .write_buffer(&render_device, &render_queue);
+}

crates/bevy_render/src/lib.rs

@@ -5,6 +5,7 @@ pub mod color;
 pub mod extract_component;
 mod extract_param;
 pub mod extract_resource;
+pub mod globals;
 pub mod mesh;
 pub mod primitives;
 pub mod rangefinder;
@@ -18,6 +19,7 @@ mod spatial_bundle;
 pub mod texture;
 pub mod view;
 
+use bevy_core::FrameCount;
 use bevy_hierarchy::ValidParentCheckPlugin;
 pub use extract_param::Extract;
 
@@ -34,6 +36,7 @@ pub mod prelude {
     };
 }
 
+use globals::GlobalsPlugin;
 pub use once_cell;
 use prelude::ComputedVisibility;
 
@@ -324,7 +327,9 @@ impl Plugin for RenderPlugin {
             .add_plugin(MeshPlugin)
             // NOTE: Load this after renderer initialization so that it knows about the supported
             // compressed texture formats
-            .add_plugin(ImagePlugin);
+            .add_plugin(ImagePlugin)
+            .add_plugin(GlobalsPlugin)
+            .add_plugin(FrameCountPlugin);
     }
 }
 
@@ -358,3 +363,22 @@ fn extract(app_world: &mut World, render_app: &mut App) {
     // see <https://github.com/bevyengine/bevy/issues/5082>
     extract.apply_buffers(running_world);
 }
+
+pub struct FrameCountPlugin;
+impl Plugin for FrameCountPlugin {
+    fn build(&self, app: &mut bevy_app::App) {
+        app.add_system(update_frame_count);
+
+        if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app.add_system_to_stage(RenderStage::Extract, extract_frame_count);
+        }
+    }
+}
+
+fn update_frame_count(mut frame_count: ResMut<FrameCount>) {
+    frame_count.0 = frame_count.0.wrapping_add(1);
+}
+
+fn extract_frame_count(mut commands: Commands, frame_count: Extract<Res<FrameCount>>) {
+    commands.insert_resource(**frame_count);
+}