update time in render stage

crates/bevy_core/src/lib.rs

@@ -53,13 +53,14 @@ impl Plugin for CorePlugin {
             .register_type::<Entity>()
             .register_type::<Name>()
             .register_type::<Range<f32>>()
-            .register_type::<Timer>()
-            // time system is added as an "exclusive system" to ensure it runs before other systems
-            // in CoreStage::First
-            .add_system_to_stage(
-                CoreStage::First,
-                time_system.exclusive_system().label(CoreSystem::Time),
-            );
+            .register_type::<Timer>();
+        // TODO: figure out how to add this when we don't have a render sub app
+        // time system is added as an "exclusive system" to ensure it runs before other systems
+        // in CoreStage::First
+        // .add_system_to_stage(
+        //     CoreStage::First,
+        //     time_system.exclusive_system().label(CoreSystem::Time),
+        // );
 
         register_rust_types(app);
         register_math_types(app);

crates/bevy_core_pipeline/Cargo.toml

@@ -19,6 +19,7 @@ trace = []
 # bevy
 bevy_app = { path = "../bevy_app", version = "0.8.0-dev" }
 bevy_asset = { path = "../bevy_asset", version = "0.8.0-dev" }
+bevy_core = { path = "../bevy_core", version = "0.8.0-dev" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.8.0-dev" }
 bevy_render = { path = "../bevy_render", version = "0.8.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.8.0-dev" }

crates/bevy_core_pipeline/src/lib.rs

@@ -20,6 +20,7 @@ pub use main_pass_driver::*;
 use std::ops::Range;
 
 use bevy_app::{App, Plugin};
+use bevy_core::prelude::Time;
 use bevy_ecs::prelude::*;
 use bevy_render::{
     camera::{ActiveCamera, Camera2d, Camera3d, ExtractedCamera, RenderTarget},
@@ -121,6 +122,7 @@ impl Plugin for CorePipelinePlugin {
         };
 
         render_app
+            .init_resource::<Time>()
             .init_resource::<DrawFunctions<Transparent2d>>()
             .init_resource::<DrawFunctions<Opaque3d>>()
             .init_resource::<DrawFunctions<AlphaMask3d>>()
@@ -140,7 +142,8 @@ impl Plugin for CorePipelinePlugin {
             )
             .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<Opaque3d>)
             .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<AlphaMask3d>)
-            .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<Transparent3d>);
+            .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<Transparent3d>)
+            .add_system_to_stage(RenderStage::ExtractToApp, extract_time_to_app);
 
         let clear_pass_node = ClearPassNode::new(&mut render_app.world);
         let pass_node_2d = MainPass2dNode::new(&mut render_app.world);
@@ -384,6 +387,12 @@ pub fn extract_core_pipeline_camera_phases(
     }
 }
 
+pub fn extract_time_to_app(mut time: ResMut<Time>, render_world: Res<RenderWorld>) {
+    if let Some(render_time) = render_world.get_resource::<Time>() {
+        std::mem::swap(&mut *time, &mut render_time.clone());
+    }
+}
+
 pub fn prepare_core_views_system(
     mut commands: Commands,
     mut texture_cache: ResMut<TextureCache>,

crates/bevy_render/src/lib.rs

@@ -78,6 +78,12 @@ pub enum RenderStage {
 
     /// Cleanup render resources here.
     Cleanup,
+
+    /// Extract data from the "render world" and insert it into the "app world".
+    /// This should be used very sparingly and will be combined with the Extract stage
+    /// when pipelined rendering is implemented. You will only be able to access resources here
+    /// entities are cleared in the cleanup stage that runs before this.
+    ExtractToApp,
 }
 
 /// The Render App World. This is only available as a resource during the Extract step.
@@ -170,6 +176,7 @@ impl Plugin for RenderPlugin {
                         .with_system(render_system.exclusive_system().at_end()),
                 )
                 .add_stage(RenderStage::Cleanup, SystemStage::parallel())
+                .add_stage(RenderStage::ExtractToApp, SystemStage::parallel())
                 .insert_resource(instance)
                 .insert_resource(device)
                 .insert_resource(queue)
@@ -276,6 +283,15 @@ impl Plugin for RenderPlugin {
 
                     render_app.world.clear_entities();
                 }
+
+                {
+                    #[cfg(feature = "trace")]
+                    let _stage_span =
+                        bevy_utils::tracing::info_span!("stage", name = "extract to app").entered();
+
+                    // extract to app
+                    extract_to_app(app_world, render_app);
+                }
             });
         }
 
@@ -311,3 +327,26 @@ fn extract(app_world: &mut World, render_app: &mut App) {
 
     extract.apply_buffers(&mut render_app.world);
 }
+
+/// Executes the [`ExtractToApp`](RenderStage::Extract) stage of the renderer.
+/// This updates the render world with the extracted ECS data of the current frame.
+fn extract_to_app(app_world: &mut World, render_app: &mut App) {
+    let extract_to_app = render_app
+        .schedule
+        .get_stage_mut::<SystemStage>(&RenderStage::ExtractToApp)
+        .unwrap();
+
+    // temporarily add the render world to the app world as a resource
+    let scratch_world = app_world.remove_resource::<ScratchRenderWorld>().unwrap();
+    let render_world = std::mem::replace(&mut render_app.world, scratch_world.0);
+    app_world.insert_resource(RenderWorld(render_world));
+
+    extract_to_app.run(app_world);
+
+    // add the render world back to the render app
+    let render_world = app_world.remove_resource::<RenderWorld>().unwrap();
+    let scratch_world = std::mem::replace(&mut render_app.world, render_world.0);
+    app_world.insert_resource(ScratchRenderWorld(scratch_world));
+
+    extract_to_app.apply_buffers(&mut render_app.world);
+}

crates/bevy_render/src/renderer/mod.rs

@@ -1,6 +1,7 @@
 mod graph_runner;
 mod render_device;
 
+use bevy_core::Time;
 use bevy_utils::tracing::{error, info, info_span};
 pub use graph_runner::*;
 pub use render_device::*;
@@ -73,6 +74,11 @@ pub fn render_system(world: &mut World) {
             tracy.frame_mark = true
         );
     }
+
+    // update time after presenting frames
+    if let Some(mut time) = world.get_resource_mut::<Time>() {
+        time.update();
+    }
 }
 
 /// This queue is used to enqueue tasks for the GPU to execute asynchronously.