Add Label type

crates/bevy_app/src/app_builder.rs

@@ -2,11 +2,11 @@ use crate::{
     app::{App, AppExit},
     event::Events,
     plugin::Plugin,
-    stage, startup_stage, PluginGroup, PluginGroupBuilder,
+    CoreStage, PluginGroup, PluginGroupBuilder, StartupStage,
 };
 use bevy_ecs::{
     clear_trackers_system, FromResources, IntoExclusiveSystem, IntoSystem, Resource, Resources,
-    RunOnce, Schedule, Stage, StateStage, SystemDescriptor, SystemStage, World,
+    RunOnce, Schedule, Stage, StageLabel, StateStage, SystemDescriptor, SystemStage, World,
 };
 use bevy_utils::tracing::debug;
 
@@ -24,7 +24,7 @@ impl Default for AppBuilder {
         app_builder
             .add_default_stages()
             .add_event::<AppExit>()
-            .add_system_to_stage(stage::LAST, clear_trackers_system.exclusive_system());
+            .add_system_to_stage(CoreStage::LAST, clear_trackers_system.exclusive_system());
         app_builder
     }
 }
@@ -54,15 +54,15 @@ impl AppBuilder {
         self
     }
 
-    pub fn add_stage<S: Stage>(&mut self, name: &'static str, stage: S) -> &mut Self {
+    pub fn add_stage<S: Stage>(&mut self, name: impl Into<StageLabel>, stage: S) -> &mut Self {
         self.app.schedule.add_stage(name, stage);
         self
     }
 
     pub fn add_stage_after<S: Stage>(
         &mut self,
-        target: &'static str,
-        name: &'static str,
+        target: impl Into<StageLabel>,
+        name: impl Into<StageLabel>,
         stage: S,
     ) -> &mut Self {
         self.app.schedule.add_stage_after(target, name, stage);
@@ -71,93 +71,97 @@ impl AppBuilder {
 
     pub fn add_stage_before<S: Stage>(
         &mut self,
-        target: &'static str,
-        name: &'static str,
+        target: impl Into<StageLabel>,
+        name: impl Into<StageLabel>,
         stage: S,
     ) -> &mut Self {
         self.app.schedule.add_stage_before(target, name, stage);
         self
     }
 
-    pub fn add_startup_stage<S: Stage>(&mut self, name: &'static str, stage: S) -> &mut Self {
+    pub fn add_startup_stage<S: Stage>(
+        &mut self,
+        name: impl Into<StageLabel>,
+        stage: S,
+    ) -> &mut Self {
         self.app
             .schedule
-            .stage(stage::STARTUP, |schedule: &mut Schedule| {
+            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
                 schedule.add_stage(name, stage)
             });
         self
     }
 
     pub fn add_startup_stage_after<S: Stage>(
         &mut self,
-        target: &'static str,
-        name: &'static str,
+        target: impl Into<StageLabel>,
+        name: impl Into<StageLabel>,
         stage: S,
     ) -> &mut Self {
         self.app
             .schedule
-            .stage(stage::STARTUP, |schedule: &mut Schedule| {
+            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
                 schedule.add_stage_after(target, name, stage)
             });
         self
     }
 
     pub fn add_startup_stage_before<S: Stage>(
         &mut self,
-        target: &'static str,
-        name: &'static str,
+        target: impl Into<StageLabel>,
+        name: impl Into<StageLabel>,
         stage: S,
     ) -> &mut Self {
         self.app
             .schedule
-            .stage(stage::STARTUP, |schedule: &mut Schedule| {
+            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
                 schedule.add_stage_before(target, name, stage)
             });
         self
     }
 
     pub fn stage<T: Stage, F: FnOnce(&mut T) -> &mut T>(
         &mut self,
-        name: &str,
+        name: impl Into<StageLabel>,
         func: F,
     ) -> &mut Self {
         self.app.schedule.stage(name, func);
         self
     }
 
     pub fn add_system(&mut self, system: impl Into<SystemDescriptor>) -> &mut Self {
-        self.add_system_to_stage(stage::UPDATE, system)
+        self.add_system_to_stage(CoreStage::Update, system)
     }
 
     pub fn add_system_to_stage(
         &mut self,
-        stage_name: &'static str,
+        stage_name: impl Into<StageLabel>,
         system: impl Into<SystemDescriptor>,
     ) -> &mut Self {
         self.app.schedule.add_system_to_stage(stage_name, system);
         self
     }
 
     pub fn add_startup_system(&mut self, system: impl Into<SystemDescriptor>) -> &mut Self {
-        self.add_startup_system_to_stage(startup_stage::STARTUP, system)
+        self.add_startup_system_to_stage(StartupStage::Startup, system)
     }
 
     pub fn add_startup_system_to_stage(
         &mut self,
-        stage_name: &'static str,
+        stage_name: impl Into<StageLabel>,
         system: impl Into<SystemDescriptor>,
     ) -> &mut Self {
         self.app
             .schedule
-            .stage(stage::STARTUP, |schedule: &mut Schedule| {
+            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
                 schedule.add_system_to_stage(stage_name, system)
             });
         self
     }
 
     pub fn on_state_enter<T: Clone + Resource>(
         &mut self,
-        stage: &str,
+        stage: impl Into<StageLabel>,
         state: T,
         system: impl Into<SystemDescriptor>,
     ) -> &mut Self {
@@ -168,7 +172,7 @@ impl AppBuilder {
 
     pub fn on_state_update<T: Clone + Resource>(
         &mut self,
-        stage: &str,
+        stage: impl Into<StageLabel>,
         state: T,
         system: impl Into<SystemDescriptor>,
     ) -> &mut Self {
@@ -179,7 +183,7 @@ impl AppBuilder {
 
     pub fn on_state_exit<T: Clone + Resource>(
         &mut self,
-        stage: &str,
+        stage: impl Into<StageLabel>,
         state: T,
         system: impl Into<SystemDescriptor>,
     ) -> &mut Self {
@@ -190,28 +194,28 @@ impl AppBuilder {
 
     pub fn add_default_stages(&mut self) -> &mut Self {
         self.add_stage(
-            stage::STARTUP,
+            CoreStage::Startup,
             Schedule::default()
                 .with_run_criteria(RunOnce::default())
-                .with_stage(startup_stage::PRE_STARTUP, SystemStage::parallel())
-                .with_stage(startup_stage::STARTUP, SystemStage::parallel())
-                .with_stage(startup_stage::POST_STARTUP, SystemStage::parallel()),
+                .with_stage(StartupStage::PreStartup, SystemStage::parallel())
+                .with_stage(StartupStage::Startup, SystemStage::parallel())
+                .with_stage(StartupStage::PostStartup, SystemStage::parallel()),
         )
-        .add_stage(stage::FIRST, SystemStage::parallel())
-        .add_stage(stage::PRE_EVENT, SystemStage::parallel())
-        .add_stage(stage::EVENT, SystemStage::parallel())
-        .add_stage(stage::PRE_UPDATE, SystemStage::parallel())
-        .add_stage(stage::UPDATE, SystemStage::parallel())
-        .add_stage(stage::POST_UPDATE, SystemStage::parallel())
-        .add_stage(stage::LAST, SystemStage::parallel())
+        .add_stage(CoreStage::First, SystemStage::parallel())
+        .add_stage(CoreStage::PreEvent, SystemStage::parallel())
+        .add_stage(CoreStage::Event, SystemStage::parallel())
+        .add_stage(CoreStage::PreUpdate, SystemStage::parallel())
+        .add_stage(CoreStage::Update, SystemStage::parallel())
+        .add_stage(CoreStage::PostUpdate, SystemStage::parallel())
+        .add_stage(CoreStage::LAST, SystemStage::parallel())
     }
 
     pub fn add_event<T>(&mut self) -> &mut Self
     where
         T: Send + Sync + 'static,
     {
         self.insert_resource(Events::<T>::default())
-            .add_system_to_stage(stage::EVENT, Events::<T>::update_system.system())
+            .add_system_to_stage(CoreStage::Event, Events::<T>::update_system.system())
     }
 
     /// Inserts a resource to the current [App] and overwrites any resource previously added of the same type.

crates/bevy_app/src/lib.rs

@@ -1,7 +1,35 @@
+use bevy_ecs::StageLabel;
+
 /// The names of the default App stages
-pub mod stage;
+#[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
+pub enum CoreStage {
+    /// Name of the app stage that runs once at the beginning of the app
+    Startup,
+    /// Name of app stage that runs before all other app stages
+    First,
+    /// Name of app stage that runs before EVENT
+    PreEvent,
+    /// Name of app stage that updates events. Runs before UPDATE
+    Event,
+    /// Name of app stage responsible for performing setup before an update. Runs before UPDATE.
+    PreUpdate,
+    /// Name of app stage responsible for doing most app logic. Systems should be registered here by default.
+    Update,
+    /// Name of app stage responsible for processing the results of UPDATE. Runs after UPDATE.
+    PostUpdate,
+    /// Name of app stage that runs after all other app stages
+    LAST,
+}
 /// The names of the default App startup stages
-pub mod startup_stage;
+#[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
+pub enum StartupStage {
+    /// Name of app stage that runs once before the startup stage
+    PreStartup,
+    /// Name of app stage that runs once when an app starts up
+    Startup,
+    /// Name of app stage that runs once after the startup stage
+    PostStartup,
+}
 
 mod app;
 mod app_builder;
@@ -23,6 +51,6 @@ pub mod prelude {
         app::App,
         app_builder::AppBuilder,
         event::{EventReader, Events},
-        stage, DynamicPlugin, Plugin, PluginGroup,
+        CoreStage, DynamicPlugin, Plugin, PluginGroup,
     };
 }

crates/bevy_asset/src/assets.rs

@@ -219,11 +219,11 @@ impl AddAsset for AppBuilder {
 
         self.insert_resource(assets)
             .add_system_to_stage(
-                super::stage::ASSET_EVENTS,
+                super::AssetStage::AssetEvents,
                 Assets::<T>::asset_event_system.system(),
             )
             .add_system_to_stage(
-                crate::stage::LOAD_ASSETS,
+                crate::AssetStage::LoadAssets,
                 update_asset_storage_system::<T>.system(),
             )
             .register_type::<Handle<T>>()

crates/bevy_asset/src/lib.rs

@@ -24,11 +24,12 @@ pub use loader::*;
 pub use path::*;
 
 /// The names of asset stages in an App Schedule
-pub mod stage {
-    pub const LOAD_ASSETS: &str = "load_assets";
-    pub const ASSET_EVENTS: &str = "asset_events";
+use bevy_ecs::StageLabel;
+#[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
+pub enum AssetStage {
+    LoadAssets,
+    AssetEvents,
 }
-
 pub mod prelude {
     pub use crate::{AddAsset, AssetEvent, AssetServer, Assets, Handle, HandleUntyped};
 }
@@ -89,25 +90,28 @@ impl Plugin for AssetPlugin {
         }
 
         app.add_stage_before(
-            bevy_app::stage::PRE_UPDATE,
-            stage::LOAD_ASSETS,
+            bevy_app::CoreStage::PreUpdate,
+            AssetStage::LoadAssets,
             SystemStage::parallel(),
         )
         .add_stage_after(
-            bevy_app::stage::POST_UPDATE,
-            stage::ASSET_EVENTS,
+            bevy_app::CoreStage::PostUpdate,
+            AssetStage::AssetEvents,
             SystemStage::parallel(),
         )
         .register_type::<HandleId>()
         .add_system_to_stage(
-            bevy_app::stage::PRE_UPDATE,
+            bevy_app::CoreStage::PreUpdate,
             asset_server::free_unused_assets_system.system(),
         );
 
         #[cfg(all(
             feature = "filesystem_watcher",
             all(not(target_arch = "wasm32"), not(target_os = "android"))
         ))]
-        app.add_system_to_stage(stage::LOAD_ASSETS, io::filesystem_watcher_system.system());
+        app.add_system_to_stage(
+            AssetStage::LoadAssets,
+            io::filesystem_watcher_system.system(),
+        );
     }
 }

crates/bevy_audio/src/lib.rs

@@ -25,7 +25,7 @@ impl Plugin for AudioPlugin {
             .init_asset_loader::<Mp3Loader>()
             .init_resource::<Audio<AudioSource>>()
             .add_system_to_stage(
-                stage::POST_UPDATE,
+                CoreStage::PostUpdate,
                 play_queued_audio_system::<AudioSource>.exclusive_system(),
             );
     }

crates/bevy_core/src/label.rs

@@ -115,15 +115,18 @@ pub(crate) fn entity_labels_system(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use bevy_ecs::Stage;
+    use bevy_ecs::{Stage, StageLabel};
+
+    #[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
+    struct Test;
 
     fn setup() -> (World, Resources, bevy_ecs::Schedule) {
         let world = World::new();
         let mut resources = Resources::default();
         resources.insert(EntityLabels::default());
         let mut schedule = bevy_ecs::Schedule::default();
-        schedule.add_stage("test", SystemStage::single_threaded());
-        schedule.add_system_to_stage("test", entity_labels_system.system());
+        schedule.add_stage(Test, SystemStage::single_threaded());
+        schedule.add_system_to_stage(Test, entity_labels_system.system());
         (world, resources, schedule)
     }