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,110 +54,114 @@ impl AppBuilder {
         self
     }
 
-    pub fn add_stage<S: Stage>(&mut self, name: &'static str, stage: S) -> &mut Self {
-        self.app.schedule.add_stage(name, stage);
+    pub fn add_stage<S: Stage>(&mut self, label: impl Into<StageLabel>, stage: S) -> &mut Self {
+        self.app.schedule.add_stage(label, stage);
         self
     }
 
     pub fn add_stage_after<S: Stage>(
         &mut self,
-        target: &'static str,
-        name: &'static str,
+        target: impl Into<StageLabel>,
+        label: impl Into<StageLabel>,
         stage: S,
     ) -> &mut Self {
-        self.app.schedule.add_stage_after(target, name, stage);
+        self.app.schedule.add_stage_after(target, label, stage);
         self
     }
 
     pub fn add_stage_before<S: Stage>(
         &mut self,
-        target: &'static str,
-        name: &'static str,
+        target: impl Into<StageLabel>,
+        label: impl Into<StageLabel>,
         stage: S,
     ) -> &mut Self {
-        self.app.schedule.add_stage_before(target, name, stage);
+        self.app.schedule.add_stage_before(target, label, 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,
+        label: impl Into<StageLabel>,
+        stage: S,
+    ) -> &mut Self {
         self.app
             .schedule
-            .stage(stage::STARTUP, |schedule: &mut Schedule| {
-                schedule.add_stage(name, stage)
+            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                schedule.add_stage(label, stage)
             });
         self
     }
 
     pub fn add_startup_stage_after<S: Stage>(
         &mut self,
-        target: &'static str,
-        name: &'static str,
+        target: impl Into<StageLabel>,
+        label: impl Into<StageLabel>,
         stage: S,
     ) -> &mut Self {
         self.app
             .schedule
-            .stage(stage::STARTUP, |schedule: &mut Schedule| {
-                schedule.add_stage_after(target, name, stage)
+            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                schedule.add_stage_after(target, label, stage)
             });
         self
     }
 
     pub fn add_startup_stage_before<S: Stage>(
         &mut self,
-        target: &'static str,
-        name: &'static str,
+        target: impl Into<StageLabel>,
+        label: impl Into<StageLabel>,
         stage: S,
     ) -> &mut Self {
         self.app
             .schedule
-            .stage(stage::STARTUP, |schedule: &mut Schedule| {
-                schedule.add_stage_before(target, name, stage)
+            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                schedule.add_stage_before(target, label, stage)
             });
         self
     }
 
     pub fn stage<T: Stage, F: FnOnce(&mut T) -> &mut T>(
         &mut self,
-        name: &str,
+        label: impl Into<StageLabel>,
         func: F,
     ) -> &mut Self {
-        self.app.schedule.stage(name, func);
+        self.app.schedule.stage(label, 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_label: impl Into<StageLabel>,
         system: impl Into<SystemDescriptor>,
     ) -> &mut Self {
-        self.app.schedule.add_system_to_stage(stage_name, system);
+        self.app.schedule.add_system_to_stage(stage_label, 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_label: impl Into<StageLabel>,
         system: impl Into<SystemDescriptor>,
     ) -> &mut Self {
         self.app
             .schedule
-            .stage(stage::STARTUP, |schedule: &mut Schedule| {
-                schedule.add_system_to_stage(stage_name, system)
+            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                schedule.add_system_to_stage(stage_label, 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,8 +1,3 @@
-/// The names of the default App stages
-pub mod stage;
-/// The names of the default App startup stages
-pub mod startup_stage;
-
 mod app;
 mod app_builder;
 mod event;
@@ -23,6 +18,39 @@ pub mod prelude {
         app::App,
         app_builder::AppBuilder,
         event::{EventReader, Events},
-        stage, DynamicPlugin, Plugin, PluginGroup,
+        CoreStage, DynamicPlugin, Plugin, PluginGroup, StartupStage,
     };
 }
+
+use bevy_ecs::StageLabel;
+
+/// The names of the default App stages
+#[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
+pub enum CoreStage {
+    /// 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
+#[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,
+}

crates/bevy_asset/src/assets.rs

@@ -1,5 +1,6 @@
 use crate::{
-    update_asset_storage_system, Asset, AssetLoader, AssetServer, Handle, HandleId, RefChange,
+    update_asset_storage_system, Asset, AssetLoader, AssetServer, AssetStage, Handle, HandleId,
+    RefChange,
 };
 use bevy_app::{prelude::Events, AppBuilder};
 use bevy_ecs::{FromResources, IntoSystem, ResMut};
@@ -219,11 +220,11 @@ impl AddAsset for AppBuilder {
 
         self.insert_resource(assets)
             .add_system_to_stage(
-                super::stage::ASSET_EVENTS,
+                AssetStage::AssetEvents,
                 Assets::<T>::asset_event_system.system(),
             )
             .add_system_to_stage(
-                crate::stage::LOAD_ASSETS,
+                AssetStage::LoadAssets,
                 update_asset_storage_system::<T>.system(),
             )
             .register_type::<Handle<T>>()