fix: added plugin registry

crates/bevy_app/src/lib.rs

@@ -12,6 +12,7 @@ mod main_schedule;
 mod panic_handler;
 mod plugin;
 mod plugin_group;
+mod plugin_registry;
 mod schedule_runner;
 mod sub_app;
 
@@ -21,19 +22,20 @@ pub use main_schedule::*;
 pub use panic_handler::*;
 pub use plugin::*;
 pub use plugin_group::*;
+pub use plugin_registry::*;
 pub use schedule_runner::*;
 pub use sub_app::*;
 
 #[allow(missing_docs)]
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        app::{App, AppExit},
+        app::{App, AppExit, AppLabel, InternedAppLabel},
         main_schedule::{
             First, FixedFirst, FixedLast, FixedPostUpdate, FixedPreUpdate, FixedUpdate, Last, Main,
             PostStartup, PostUpdate, PreStartup, PreUpdate, SpawnScene, Startup, Update,
         },
         sub_app::SubApp,
-        DynamicPlugin, Plugin, PluginGroup,
+        DynamicPlugin, Plugin, PluginGroup, PluginState,
     };
 }

crates/bevy_app/src/main_schedule.rs

@@ -237,6 +237,30 @@ impl Main {
 pub struct MainSchedulePlugin;
 
 impl Plugin for MainSchedulePlugin {
+    fn init(&self, app: &mut App) {
+        // simple "facilitator" schedules benefit from simpler single threaded scheduling
+        let mut main_schedule = Schedule::new(Main);
+        main_schedule.set_executor_kind(ExecutorKind::SingleThreaded);
+        let mut fixed_main_schedule = Schedule::new(FixedMain);
+        fixed_main_schedule.set_executor_kind(ExecutorKind::SingleThreaded);
+        let mut fixed_main_loop_schedule = Schedule::new(RunFixedMainLoop);
+        fixed_main_loop_schedule.set_executor_kind(ExecutorKind::SingleThreaded);
+
+        app.add_schedule(main_schedule)
+            .add_schedule(fixed_main_schedule)
+            .add_schedule(fixed_main_loop_schedule)
+            .init_resource::<MainScheduleOrder>()
+            .init_resource::<FixedMainScheduleOrder>()
+            .add_systems(Main, Main::run_main)
+            .add_systems(FixedMain, FixedMain::run_fixed_main);
+
+        #[cfg(feature = "bevy_debug_stepping")]
+        {
+            use bevy_ecs::schedule::{IntoSystemConfigs, Stepping};
+            app.add_systems(Main, Stepping::begin_frame.before(Main::run_main));
+        }
+    }
+
     fn build(&self, app: &mut App) {
         // simple "facilitator" schedules benefit from simpler single threaded scheduling
         let mut main_schedule = Schedule::new(Main);

crates/bevy_app/src/plugin.rs

@@ -1,8 +1,41 @@
 use downcast_rs::{impl_downcast, Downcast};
 
-use crate::App;
+use crate::{App, InternedAppLabel};
 use std::any::Any;
 
+/// Plugin state in the application
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub enum PluginState {
+    /// Plugin is not initialized.
+    #[default]
+    Idle,
+    /// Plugin is initialized.
+    Init,
+    /// Plugin is being built.
+    Building,
+    /// Plugin is being configured.
+    Configuring,
+    /// Plugin configuration is finishing.
+    Finalizing,
+    /// Plugin configuration is completed.
+    Done,
+    /// Plugin resources are cleaned up.
+    Cleaned,
+}
+
+impl PluginState {
+    pub(crate) fn next(self) -> Self {
+        match self {
+            Self::Idle => Self::Init,
+            Self::Init => Self::Building,
+            Self::Building => Self::Configuring,
+            Self::Configuring => Self::Finalizing,
+            Self::Finalizing => Self::Done,
+            s => unreachable!("Cannot handle {:?} state", s),
+        }
+    }
+}
+
 /// A collection of Bevy app logic and configuration.
 ///
 /// Plugins configure an [`App`]. When an [`App`] registers a plugin,
@@ -19,7 +52,7 @@ use std::any::Any;
 /// When adding a plugin to an [`App`]:
 /// * the app calls [`Plugin::build`] immediately, and register the plugin
 /// * once the app started, it will wait for all registered [`Plugin::ready`] to return `true`
-/// * it will then call all registered [`Plugin::finish`]
+/// * it will then call all registered [`Plugin::finalize`]
 /// * and call all registered [`Plugin::cleanup`]
 ///
 /// ## Defining a plugin.
@@ -56,19 +89,46 @@ use std::any::Any;
 /// # fn damp_flickering() {}
 /// ````
 pub trait Plugin: Downcast + Any + Send + Sync {
-    /// Configures the [`App`] to which this plugin is added.
-    fn build(&self, app: &mut App);
+    /// Returns required sub apps before finalizing this plugin.
+    fn require_sub_apps(&self) -> Vec<InternedAppLabel> {
+        Vec::new()
+    }
 
-    /// Has the plugin finished its setup? This can be useful for plugins that need something
-    /// asynchronous to happen before they can finish their setup, like the initialization of a renderer.
-    /// Once the plugin is ready, [`finish`](Plugin::finish) should be called.
-    fn ready(&self, _app: &App) -> bool {
+    /// Pre-configures the [`App`] to which this plugin is added. This is usually executed before
+    /// the event loop is started.
+    fn init(&self, _app: &mut App) {
+        // do nothing
+    }
+
+    /// Is the plugin ready to be built?
+    fn ready_to_build(&self, _app: &mut App) -> bool {
         true
     }
 
-    /// Finish adding this plugin to the [`App`], once all plugins registered are ready. This can
+    /// Builds the [`Plugin`] resources. This is usually executed inside an event loop.
+    fn build(&self, _app: &mut App) {
+        // do nothing
+    }
+
+    /// Is the plugin ready to be configured?
+    fn ready_to_configure(&self, _app: &mut App) -> bool {
+        true
+    }
+
+    /// Configures the [`App`] to which this plugin is added. This can
+    /// be useful for plugins that needs completing asynchronous configuration.
+    fn configure(&self, _app: &mut App) {
+        // do nothing
+    }
+
+    /// Is the plugin ready to be finalized?
+    fn ready_to_finalize(&self, _app: &mut App) -> bool {
+        true
+    }
+
+    /// Finalizes this plugin to the [`App`]. This can
     /// be useful for plugins that depends on another plugin asynchronous setup, like the renderer.
-    fn finish(&self, _app: &mut App) {
+    fn finalize(&self, _app: &mut App) {
         // do nothing
     }
 
@@ -90,6 +150,35 @@ pub trait Plugin: Downcast + Any + Send + Sync {
     fn is_unique(&self) -> bool {
         true
     }
+
+    /// Updates the plugin to a desired [`PluginState`].
+    fn update(&mut self, app: &mut App, state: PluginState) {
+        match state {
+            PluginState::Init => self.init(app),
+            PluginState::Building => self.build(app),
+            PluginState::Configuring => self.configure(app),
+            PluginState::Finalizing => self.finalize(app),
+            PluginState::Done => {}
+            s => panic!("Cannot handle {s:?} state"),
+        }
+    }
+
+    /// Updates if the plugin is ready to progress to the desired next [`PluginState`].
+    fn ready(&self, app: &mut App, next_state: PluginState) -> bool {
+        match next_state {
+            PluginState::Building => self.ready_to_build(app),
+            PluginState::Configuring => self.ready_to_configure(app),
+            PluginState::Finalizing => self.ready_to_finalize(app),
+            _ => true,
+        }
+    }
+
+    /// Checks all required [`SubApp`]s.
+    fn check_required_sub_apps(&mut self, app: &App) -> bool {
+        self.require_sub_apps()
+            .iter()
+            .all(|s| app.contains_sub_app(*s))
+    }
 }
 
 impl_downcast!(Plugin);
@@ -100,26 +189,6 @@ impl<T: Fn(&mut App) + Send + Sync + 'static> Plugin for T {
     }
 }
 
-/// Plugins state in the application
-#[derive(PartialEq, Eq, Debug, Clone, Copy, PartialOrd, Ord)]
-pub enum PluginsState {
-    /// Plugins are being added.
-    Adding,
-    /// All plugins already added are ready.
-    Ready,
-    /// Finish has been executed for all plugins added.
-    Finished,
-    /// Cleanup has been executed for all plugins added.
-    Cleaned,
-}
-
-/// A dummy plugin that's to temporarily occupy an entry in an app's plugin registry.
-pub(crate) struct PlaceholderPlugin;
-
-impl Plugin for PlaceholderPlugin {
-    fn build(&self, _app: &mut App) {}
-}
-
 /// A type representing an unsafe function that returns a mutable pointer to a [`Plugin`].
 /// It is used for dynamically loading plugins.
 ///