Rename the main schedule label

Author: B-head

crates/bevy_app/src/app.rs

@@ -1,4 +1,6 @@
-use crate::{First, Main, MainSchedulePlugin, Plugin, Plugins, Startup, StateTransition, Update};
+use crate::{
+    First, MainSchedulePlugin, Plugin, Plugins, Startup, StateTransition, Update, UpdateFlow,
+};
 pub use bevy_derive::AppLabel;
 use bevy_ecs::{
     prelude::*,
@@ -94,7 +96,7 @@ impl Debug for App {
 /// # Example
 ///
 /// ```rust
-/// # use bevy_app::{App, AppLabel, SubApp, Main};
+/// # use bevy_app::{App, AppLabel, SubApp, UpdateFlow};
 /// # use bevy_ecs::prelude::*;
 /// # use bevy_ecs::schedule::ScheduleLabel;
 ///
@@ -115,7 +117,7 @@ impl Debug for App {
 /// sub_app.insert_resource(Val(100));
 ///
 /// // initialize main schedule
-/// sub_app.add_systems(Main, |counter: Res<Val>| {
+/// sub_app.add_systems(UpdateFlow, |counter: Res<Val>| {
 ///     // since we assigned the value from the main world in extract
 ///     // we see that value instead of 100
 ///     assert_eq!(counter.0, 10);
@@ -136,7 +138,7 @@ pub struct SubApp {
 
     /// The schedule to run by default.
     ///
-    /// This is initially set to [`Main`].
+    /// This is initially set to [`UpdateFlow`].
     pub main_schedule_label: BoxedScheduleLabel,
 
     /// A function that allows access to both the main [`App`] [`World`] and the [`SubApp`]. This is
@@ -154,7 +156,7 @@ impl SubApp {
     pub fn new(app: App, extract: impl Fn(&mut World, &mut App) + Send + Sync + 'static) -> Self {
         Self {
             app,
-            main_schedule_label: Box::new(Main),
+            main_schedule_label: Box::new(UpdateFlow),
             extract: Box::new(extract),
         }
     }
@@ -635,7 +637,7 @@ impl App {
     /// fn my_runner(mut app: App) {
     ///     loop {
     ///         println!("In main loop");
-    ///         app.world.run_schedule(Main);
+    ///         app.world.run_schedule(UpdateFlow);
     ///     }
     /// }
     ///
@@ -963,8 +965,8 @@ fn run_once(mut app: App) {
 
     {
         #[cfg(feature = "trace")]
-        let _main_schedule_span = info_span!("main schedule", name = ?Main).entered();
-        app.world.run_schedule(Main);
+        let _ = info_span!("run top schedule", name = ?UpdateFlow).entered();
+        app.world.run_schedule(UpdateFlow);
     }
     app.update_sub_apps();
 }

crates/bevy_app/src/lib.rs

@@ -25,7 +25,7 @@ pub mod prelude {
     pub use crate::{
         app::App,
         main_schedule::{
-            First, FixedUpdate, Last, Main, PostStartup, PostUpdate, PreStartup, PreUpdate, Render,
+            First, FixedUpdate, Last, UpdateFlow, PostStartup, PostUpdate, PreStartup, PreUpdate, RenderFlow,
             Startup, StateTransition, Update,
         },
         DynamicPlugin, Plugin, PluginGroup,

crates/bevy_app/src/main_schedule.rs

@@ -24,7 +24,7 @@ use bevy_ecs::{
 /// * [`PostUpdate`]
 /// * [`Last`]
 #[derive(ScheduleLabel, Clone, Debug, PartialEq, Eq, Hash)]
-pub struct Main;
+pub struct UpdateFlow;
 
 /// The schedule that runs before [`Startup`].
 /// This is run by the [`Main`] schedule.
@@ -97,17 +97,17 @@ pub struct Last;
 
 /// The main render schedule.
 #[derive(ScheduleLabel, Debug, Hash, PartialEq, Eq, Clone)]
-pub struct Render;
+pub struct RenderFlow;
 
-/// Defines the schedules to be run for the [`Main`] schedule, including
+/// Defines the schedules to be run for the [`UpdateFlow`] schedule, including
 /// their order.
 #[derive(Resource, Debug)]
-pub struct MainScheduleOrder {
-    /// The labels to run for the [`Main`] schedule (in the order they will be run).
+pub struct UpdateFlowOrder {
+    /// The labels to run for the [`UpdateFlow`] schedule (in the order they will be run).
     pub labels: Vec<Box<dyn ScheduleLabel>>,
 }
 
-impl Default for MainScheduleOrder {
+impl Default for UpdateFlowOrder {
     fn default() -> Self {
         Self {
             labels: vec![
@@ -123,7 +123,7 @@ impl Default for MainScheduleOrder {
     }
 }
 
-impl MainScheduleOrder {
+impl UpdateFlowOrder {
     /// Adds the given `schedule` after the `after` schedule
     pub fn insert_after(&mut self, after: impl ScheduleLabel, schedule: impl ScheduleLabel) {
         let index = self
@@ -135,7 +135,7 @@ impl MainScheduleOrder {
     }
 }
 
-impl Main {
+impl UpdateFlow {
     /// A system that runs the "main schedule"
     pub fn run_main(world: &mut World, mut run_at_least_once: Local<bool>) {
         if !*run_at_least_once {
@@ -145,7 +145,7 @@ impl Main {
             *run_at_least_once = true;
         }
 
-        world.resource_scope(|world, order: Mut<MainScheduleOrder>| {
+        world.resource_scope(|world, order: Mut<UpdateFlowOrder>| {
             for label in &order.labels {
                 let _ = world.try_run_schedule(&**label);
             }
@@ -164,9 +164,9 @@ impl Plugin for MainSchedulePlugin {
         let mut fixed_update_loop_schedule = Schedule::new();
         fixed_update_loop_schedule.set_executor_kind(ExecutorKind::SingleThreaded);
 
-        app.add_schedule(Main, main_schedule)
+        app.add_schedule(UpdateFlow, main_schedule)
             .add_schedule(RunFixedUpdateLoop, fixed_update_loop_schedule)
-            .init_resource::<MainScheduleOrder>()
-            .add_systems(Main, Main::run_main);
+            .init_resource::<UpdateFlowOrder>()
+            .add_systems(UpdateFlow, UpdateFlow::run_main);
     }
 }

crates/bevy_app/src/schedule_runner.rs

@@ -1,7 +1,7 @@
 use crate::{
     app::{App, AppExit},
     plugin::Plugin,
-    Main,
+    UpdateFlow,
 };
 use bevy_ecs::{
     event::{Events, ManualEventReader},
@@ -64,7 +64,7 @@ impl ScheduleRunnerPlugin {
     pub fn run_once() -> Self {
         ScheduleRunnerPlugin {
             run_mode: RunMode::Once,
-            main_schedule_label: Box::new(Main),
+            main_schedule_label: Box::new(UpdateFlow),
         }
     }
 
@@ -74,7 +74,7 @@ impl ScheduleRunnerPlugin {
             run_mode: RunMode::Loop {
                 wait: Some(wait_duration),
             },
-            main_schedule_label: Box::new(Main),
+            main_schedule_label: Box::new(UpdateFlow),
         }
     }
 }
@@ -83,7 +83,7 @@ impl Default for ScheduleRunnerPlugin {
     fn default() -> Self {
         ScheduleRunnerPlugin {
             run_mode: RunMode::Loop { wait: None },
-            main_schedule_label: Box::new(Main),
+            main_schedule_label: Box::new(UpdateFlow),
         }
     }
 }

crates/bevy_asset/src/asset_server.rs

@@ -645,7 +645,7 @@ pub fn free_unused_assets_system(asset_server: Res<AssetServer>) {
 mod test {
     use super::*;
     use crate::{loader::LoadedAsset, update_asset_storage_system};
-    use bevy_app::{App, Main, Update};
+    use bevy_app::{App, Update, UpdateFlow};
     use bevy_ecs::prelude::*;
     use bevy_reflect::{TypePath, TypeUuid};
     use bevy_utils::BoxedFuture;
@@ -896,19 +896,19 @@ mod test {
         // asset is loading
         assert_eq!(LoadState::Loading, get_load_state(&handle, &app.world));
 
-        app.world.run_schedule(Main);
+        app.world.run_schedule(UpdateFlow);
         // asset should exist and be loaded at this point
         assert_eq!(LoadState::Loaded, get_load_state(&handle, &app.world));
         assert!(get_asset(&handle, &app.world).is_some());
 
         // after dropping the handle, next call to `tick` will prepare the assets for removal.
         drop(handle);
-        app.world.run_schedule(Main);
+        app.world.run_schedule(UpdateFlow);
         assert_eq!(LoadState::Loaded, get_load_state(&weak_handle, &app.world));
         assert!(get_asset(&weak_handle, &app.world).is_some());
 
         // second call to tick will actually remove the asset.
-        app.world.run_schedule(Main);
+        app.world.run_schedule(UpdateFlow);
         assert_eq!(
             LoadState::Unloaded,
             get_load_state(&weak_handle, &app.world)
@@ -918,7 +918,7 @@ mod test {
         // finally, reload the asset
         let handle = load_asset(path.clone(), &app.world).typed();
         assert_eq!(LoadState::Loading, get_load_state(&handle, &app.world));
-        app.world.run_schedule(Main);
+        app.world.run_schedule(UpdateFlow);
         assert_eq!(LoadState::Loaded, get_load_state(&handle, &app.world));
         assert!(get_asset(&handle, &app.world).is_some());
     }

crates/bevy_asset/src/debug_asset_server.rs

@@ -2,7 +2,7 @@
 //!
 //! Internal assets (e.g. shaders) are bundled directly into an application and can't be hot
 //! reloaded using the conventional API.
-use bevy_app::{App, Main, Plugin, Update};
+use bevy_app::{App, Plugin, Update, UpdateFlow};
 use bevy_ecs::{prelude::*, system::SystemState};
 use bevy_tasks::{IoTaskPool, TaskPoolBuilder};
 use bevy_utils::{Duration, HashMap};
@@ -81,7 +81,7 @@ impl Plugin for DebugAssetServerPlugin {
 }
 
 fn run_debug_asset_app(mut debug_asset_app: NonSendMut<DebugAssetApp>) {
-    debug_asset_app.0.world.run_schedule(Main);
+    debug_asset_app.0.world.run_schedule(UpdateFlow);
 }
 
 pub(crate) fn sync_debug_assets<T: Asset + Clone>(

crates/bevy_asset/src/lib.rs

@@ -47,7 +47,7 @@ pub use loader::*;
 pub use path::*;
 pub use reflect::*;
 
-use bevy_app::{prelude::*, MainScheduleOrder};
+use bevy_app::{prelude::*, UpdateFlowOrder};
 use bevy_ecs::schedule::ScheduleLabel;
 use bevy_utils::Duration;
 
@@ -142,7 +142,7 @@ impl Plugin for AssetPlugin {
         ))]
         app.add_systems(LoadAssets, io::filesystem_watcher_system);
 
-        let mut order = app.world.resource_mut::<MainScheduleOrder>();
+        let mut order = app.world.resource_mut::<UpdateFlowOrder>();
         order.insert_after(First, LoadAssets);
         order.insert_after(PostUpdate, AssetEvents);
     }

crates/bevy_core/src/lib.rs

@@ -203,7 +203,7 @@ mod tests {
             TypeRegistrationPlugin::default(),
             FrameCountPlugin::default(),
         ));
-        app.world.run_schedule(Main);
+        app.world.run_schedule(UpdateFlow);
 
         let frame_count = app.world.resource::<FrameCount>();
         assert_eq!(1, frame_count.0);

crates/bevy_core_pipeline/src/bloom/mod.rs

@@ -8,7 +8,7 @@ use crate::{
     core_2d::{self, CORE_2D},
     core_3d::{self, CORE_3D},
 };
-use bevy_app::{App, Plugin, Render};
+use bevy_app::{App, Plugin, RenderFlow};
 use bevy_asset::{load_internal_asset, HandleUntyped};
 use bevy_ecs::{prelude::*, query::QueryItem};
 use bevy_math::UVec2;
@@ -66,7 +66,7 @@ impl Plugin for BloomPlugin {
             .init_resource::<SpecializedRenderPipelines<BloomDownsamplingPipeline>>()
             .init_resource::<SpecializedRenderPipelines<BloomUpsamplingPipeline>>()
             .add_systems(
-                Render,
+                RenderFlow,
                 (
                     prepare_bloom_textures.in_set(RenderSet::Prepare),
                     prepare_downsampling_pipeline.in_set(RenderSet::Prepare),

crates/bevy_core_pipeline/src/contrast_adaptive_sharpening/mod.rs

@@ -119,7 +119,7 @@ impl Plugin for CASPlugin {
         };
         render_app
             .init_resource::<SpecializedRenderPipelines<CASPipeline>>()
-            .add_systems(Render, prepare_cas_pipelines.in_set(RenderSet::Prepare));
+            .add_systems(RenderFlow, prepare_cas_pipelines.in_set(RenderSet::Prepare));
 
         {
             use core_3d::graph::node::*;