Struct bevy_app::App

pub struct App {
    pub world: World,
    pub runner: Box<dyn Fn(App) + Send>,
    pub default_schedule_label: BoxedScheduleLabel,
    pub outer_schedule_label: BoxedScheduleLabel,
    /* private fields */
}

A container of app logic and data.

Bundles together the necessary elements like World and Schedule to create an ECS-based application. It also stores a pointer to a runner function. The runner is responsible for managing the application’s event loop and applying the Schedule to the World to drive application logic.

Examples

Here is a simple “Hello World” Bevy app:

fn main() {
   App::new()
       .add_system(hello_world_system)
       .run();
}

fn hello_world_system() {
   println!("hello world");
}

Fields

world: World

The main ECS World of the App. This stores and provides access to all the main data of the application. The systems of the App will run using this World. If additional separate World-Schedule pairs are needed, you can use sub_apps.

runner: Box<dyn Fn(App) + Send>

The runner function is primarily responsible for managing the application’s event loop and advancing the Schedule. Typically, it is not configured manually, but set by one of Bevy’s built-in plugins. See bevy::winit::WinitPlugin and ScheduleRunnerPlugin.

default_schedule_label: BoxedScheduleLabel

The schedule that systems are added to by default.

This is initially set to CoreSchedule::Main.

outer_schedule_label: BoxedScheduleLabel

The schedule that controls the outer loop of schedule execution.

This is initially set to CoreSchedule::Outer.

Implementations

impl App

pub fn new() -> App

Creates a new App with some default structure to enable core engine features. This is the preferred constructor for most use cases.

This calls App::add_default_schedules.

pub fn empty() -> App

Creates a new empty App with minimal default configuration.

This constructor should be used if you wish to provide custom scheduling, exit handling, cleanup, etc.

pub fn update(&mut self)

Advances the execution of the Schedule by one cycle.

This method also updates sub apps. See insert_sub_app for more details.

The schedule run by this method is determined by the outer_schedule_label field. In normal usage, this is CoreSchedule::Outer, which will run CoreSchedule::Startup the first time the app is run, then CoreSchedule::Main on every call of this method.

Panics

The active schedule of the app must be set before this method is called.

pub fn run(&mut self)

Starts the application by calling the app’s runner function.

Finalizes the App configuration. For general usage, see the example on the item level documentation.

run() might not return

Calls to App::run() might never return.

In simple and headless applications, one can expect that execution will proceed, normally, after calling run() but this is not the case for windowed applications.

Windowed apps are typically driven by an event loop or message loop and some window-manager APIs expect programs to terminate when their primary window is closed and that event loop terminates – behaviour of processes that do not is often platform dependent or undocumented.

By default, Bevy uses the winit crate for window creation. See WinitSettings::return_from_run for further discussion of this topic and for a mechanism to require that App::run() does return – albeit one that carries its own caveats and disclaimers.

Panics

Panics if called from Plugin::build(), because it would prevent other plugins to properly build.

pub fn setup(&mut self)

Run Plugin::setup for each plugin. This is usually called by App::run, but can be useful for situations where you want to use App::update.

pub fn add_state<S: States>(&mut self) -> &mut Self

Adds State<S> and NextState<S> resources, OnEnter and OnExit schedules for each state variant, an instance of apply_state_transition::<S> in CoreSet::StateTransitions so that transitions happen before CoreSet::Update and a instance of run_enter_schedule::<S> in CoreSet::StateTransitions with a run_once condition to run the on enter schedule of the initial state.

This also adds an OnUpdate system set for each state variant, which runs during CoreSet::Update after the transitions are applied. These system sets only run if the State<S> resource matches the respective state variant.

If you would like to control how other systems run based on the current state, you can emulate this behavior using the in_state Condition.

Note that you can also apply state transitions at other points in the schedule by adding the apply_state_transition system manually.

pub fn add_system<M>( &mut self, system: impl IntoSystemAppConfig<M> ) -> &mut Self

Adds a system to the default system set and schedule of the app’s Schedules.

Refer to the system module documentation to see how a system can be defined.

Examples

app.add_system(my_system);

pub fn add_systems<M>( &mut self, systems: impl IntoSystemAppConfigs<M> ) -> &mut Self

Adds a system to the default system set and schedule of the app’s Schedules.

Examples

app.add_systems((system_a, system_b, system_c));

pub fn add_startup_system<M>( &mut self, system: impl IntoSystemConfig<M> ) -> &mut Self

Adds a system to CoreSchedule::Startup.

These systems will run exactly once, at the start of the App’s lifecycle. To add a system that runs every frame, see add_system.

Examples

fn my_startup_system(_commands: Commands) {
    println!("My startup system");
}

App::new()
    .add_startup_system(my_startup_system);

pub fn add_startup_systems<M>( &mut self, systems: impl IntoSystemConfigs<M> ) -> &mut Self

Adds a collection of systems to CoreSchedule::Startup.

Examples

app.add_startup_systems((
    startup_system_a,
    startup_system_b,
    startup_system_c,
));

pub fn configure_set(&mut self, set: impl IntoSystemSetConfig) -> &mut Self

Configures a system set in the default schedule, adding the set if it does not exist.

pub fn configure_sets(&mut self, sets: impl IntoSystemSetConfigs) -> &mut Self

Configures a collection of system sets in the default schedule, adding any sets that do not exist.

pub fn add_default_schedules(&mut self) -> &mut Self

Adds standardized schedules and labels to an App.

Adding these schedules is necessary to make almost all core engine features work. This is typically done implicitly by calling App::default, which is in turn called by App::new.

The schedules added are defined in the CoreSchedule enum, and have a starting configuration defined by:

• CoreSchedule::Outer: uses CoreSchedule::outer_schedule
• CoreSchedule::Startup: uses StartupSet::base_schedule
• CoreSchedule::Main: uses CoreSet::base_schedule
• CoreSchedule::FixedUpdate: no starting configuration

Examples

use bevy_app::App;
use bevy_ecs::schedule::Schedules;

let app = App::empty()
    .init_resource::<Schedules>()
    .add_default_schedules()
    .update();

pub fn add_simple_outer_schedule(&mut self) -> &mut Self

adds a single threaded outer schedule to the App that just runs the main schedule

pub fn add_event<T>(&mut self) -> &mut Selfwhere T: Event,

Setup the application to manage events of type T.

This is done by adding a Resource of type Events::<T>, and inserting an update_system into CoreSet::First.

See Events for defining events.

Examples

app.add_event::<MyEvent>();

pub fn insert_resource<R: Resource>(&mut self, resource: R) -> &mut Self

Inserts a Resource to the current App and overwrites any Resource previously added of the same type.

A Resource in Bevy represents globally unique data. Resources must be added to Bevy apps before using them. This happens with insert_resource.

See init_resource for Resources that implement Default or FromWorld.

Examples

#[derive(Resource)]
struct MyCounter {
    counter: usize,
}

App::new()
   .insert_resource(MyCounter { counter: 0 });

pub fn insert_non_send_resource<R: 'static>(&mut self, resource: R) -> &mut Self

Inserts a non-send resource to the app.

You usually want to use insert_resource, but there are some special cases when a resource cannot be sent across threads.

Examples

struct MyCounter {
    counter: usize,
}

App::new()
    .insert_non_send_resource(MyCounter { counter: 0 });

pub fn init_resource<R: Resource + FromWorld>(&mut self) -> &mut Self

Initialize a Resource with standard starting values by adding it to the World.

If the Resource already exists, nothing happens.

The Resource must implement the FromWorld trait. If the Default trait is implemented, the FromWorld trait will use the Default::default method to initialize the Resource.

Examples

#[derive(Resource)]
struct MyCounter {
    counter: usize,
}

impl Default for MyCounter {
    fn default() -> MyCounter {
        MyCounter {
            counter: 100
        }
    }
}

App::new()
    .init_resource::<MyCounter>();

pub fn init_non_send_resource<R: 'static + FromWorld>(&mut self) -> &mut Self

Initialize a non-send Resource with standard starting values by adding it to the World.

The Resource must implement the FromWorld trait. If the Default trait is implemented, the FromWorld trait will use the Default::default method to initialize the Resource.

pub fn set_runner(&mut self, run_fn: impl Fn(App) + 'static + Send) -> &mut Self

Sets the function that will be called when the app is run.

The runner function run_fn is called only once by App::run. If the presence of a main loop in the app is desired, it is the responsibility of the runner function to provide it.

The runner function is usually not set manually, but by Bevy integrated plugins (e.g. WinitPlugin).

Examples

fn my_runner(mut app: App) {
    loop {
        println!("In main loop");
        app.update();
    }
}

App::new()
    .set_runner(my_runner);

pub fn add_plugin<T>(&mut self, plugin: T) -> &mut Selfwhere T: Plugin,

Adds a single Plugin.

One of Bevy’s core principles is modularity. All Bevy engine features are implemented as Plugins. This includes internal features like the renderer.

Bevy also provides a few sets of default Plugins. See add_plugins.

Examples

App::new().add_plugin(bevy_log::LogPlugin::default());

Panics

Panics if the plugin was already added to the application.

pub fn is_plugin_added<T>(&self) -> boolwhere T: Plugin,

Checks if a Plugin has already been added.

This can be used by plugins to check if a plugin they depend upon has already been added.

pub fn get_added_plugins<T>(&self) -> Vec<&T>where T: Plugin,

Returns a vector of references to any plugins of type T that have been added.

This can be used to read the settings of any already added plugins. This vector will be length zero if no plugins of that type have been added. If multiple copies of the same plugin are added to the App, they will be listed in insertion order in this vector.

let default_sampler = app.get_added_plugins::<ImagePlugin>()[0].default_sampler;

pub fn add_plugins<T: PluginGroup>(&mut self, group: T) -> &mut Self

Adds a group of Plugins.

Plugins can be grouped into a set by using a PluginGroup.

There are built-in PluginGroups that provide core engine functionality. The PluginGroups available by default are DefaultPlugins and MinimalPlugins.

To customize the plugins in the group (reorder, disable a plugin, add a new plugin before / after another plugin), call build() on the group, which will convert it to a PluginGroupBuilder.

Examples

App::new()
    .add_plugins(MinimalPlugins);

Panics

Panics if one of the plugin in the group was already added to the application.

pub fn register_type<T: GetTypeRegistration>(&mut self) -> &mut Self

Registers the type T in the TypeRegistry resource, adding reflect data as specified in the Reflect derive:

#[derive(Reflect)]
#[reflect(Component, Serialize, Deserialize)] // will register ReflectComponent, ReflectSerialize, ReflectDeserialize

See bevy_reflect::TypeRegistry::register.

pub fn register_type_data<T: Reflect + 'static, D: TypeData + FromType<T>>( &mut self ) -> &mut Self

Adds the type data D to type T in the TypeRegistry resource.

Most of the time App::register_type can be used instead to register a type you derived Reflect for. However, in cases where you want to add a piece of type data that was not included in the list of #[reflect(...)] type data in the derive, or where the type is generic and cannot register e.g. ReflectSerialize unconditionally without knowing the specific type parameters, this method can be used to insert additional type data.

Example

use bevy_app::App;
use bevy_reflect::{ReflectSerialize, ReflectDeserialize};

App::new()
    .register_type::<Option<String>>()
    .register_type_data::<Option<String>, ReflectSerialize>()
    .register_type_data::<Option<String>, ReflectDeserialize>();

See bevy_reflect::TypeRegistry::register_type_data.

pub fn sub_app_mut(&mut self, label: impl AppLabel) -> &mut App

Retrieves a SubApp stored inside this App.

Panics

Panics if the SubApp doesn’t exist.

pub fn get_sub_app_mut( &mut self, label: impl AppLabel ) -> Result<&mut App, AppLabelId>

Retrieves a SubApp inside this App with the given label, if it exists. Otherwise returns an Err containing the given label.

pub fn sub_app(&self, label: impl AppLabel) -> &App

Retrieves a SubApp stored inside this App.

Panics

Panics if the SubApp doesn’t exist.

pub fn insert_sub_app(&mut self, label: impl AppLabel, sub_app: SubApp)

Inserts an existing sub app into the app

pub fn remove_sub_app(&mut self, label: impl AppLabel) -> Option<SubApp>

Removes a sub app from the app. Returns None if the label doesn’t exist.

pub fn get_sub_app(&self, label: impl AppLabel) -> Result<&App, impl AppLabel>

Retrieves a SubApp inside this App with the given label, if it exists. Otherwise returns an Err containing the given label.

pub fn add_schedule( &mut self, label: impl ScheduleLabel, schedule: Schedule ) -> &mut Self

Adds a new schedule to the App under the provided label.

Warning

This method will overwrite any existing schedule at that label. To avoid this behavior, use the init_schedule method instead.

pub fn init_schedule(&mut self, label: impl ScheduleLabel) -> &mut Self

Initializes a new empty schedule to the App under the provided label if it does not exists.

See App::add_schedule to pass in a pre-constructed schedule.

pub fn get_schedule(&self, label: impl ScheduleLabel) -> Option<&Schedule>

Gets read-only access to the Schedule with the provided label if it exists.

pub fn get_schedule_mut( &mut self, label: impl ScheduleLabel ) -> Option<&mut Schedule>

Gets read-write access to a Schedule with the provided label if it exists.

pub fn edit_schedule( &mut self, label: impl ScheduleLabel, f: impl FnMut(&mut Schedule) ) -> &mut Self

Applies the function to the Schedule associated with label.

Note: This will create the schedule if it does not already exist.

Trait Implementations

impl Debug for App

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for App

fn default() -> Self

Returns the “default value” for a type.