bevy::app

Struct App

Source 
pub struct App { /* private fields */ }
Expand description

App is the primary API for writing user applications. It automates the setup of a standard lifecycle and provides interface glue for plugins.

A single App can contain multiple SubApp instances, but App methods only affect the “main” one. To access a particular SubApp, use get_sub_app or get_sub_app_mut.

§Examples

Here is a simple “Hello World” Bevy app:

fn main() {
   App::new()
       .add_systems(Update, hello_world_system)
       .run();
}

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

Implementations§

Source§

impl App

Source

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.

Examples found in repository?
examples/app/empty.rs (line 6)
5fn main() {
6    App::new().run();
7}
More examples
Hide additional examples
examples/app/empty_defaults.rs (line 6)
5fn main() {
6    App::new().add_plugins(DefaultPlugins).run();
7}
examples/hello_world.rs (line 6)
5fn main() {
6    App::new().add_systems(Update, hello_world_system).run();
7}
examples/2d/mesh2d.rs (line 6)
5fn main() {
6    App::new()
7        .add_plugins(DefaultPlugins)
8        .add_systems(Startup, setup)
9        .run();
10}
examples/2d/mesh2d_alpha_mode.rs (line 11)
10fn main() {
11    App::new()
12        .add_plugins(DefaultPlugins)
13        .add_systems(Startup, setup)
14        .run();
15}
examples/2d/mesh2d_vertex_color_texture.rs (line 7)
6fn main() {
7    App::new()
8        .add_plugins(DefaultPlugins)
9        .add_systems(Startup, setup)
10        .run();
11}
Additional examples can be found in:
Source

pub fn empty() -> App

Creates a new empty App with minimal default configuration.

Use this constructor if you want to customize scheduling, exit handling, cleanup, etc.

Source

pub fn update(&mut self)

Runs the default schedules of all sub-apps (starting with the “main” app) once.

Examples found in repository?
examples/app/custom_loop.rs (line 22)
10fn my_runner(mut app: App) -> AppExit {
11    // Finalize plugin building, including running any necessary clean-up.
12    // This is normally completed by the default runner.
13    app.finish();
14    app.cleanup();
15
16    println!("Type stuff into the console");
17    for line in io::stdin().lines() {
18        {
19            let mut input = app.world_mut().resource_mut::<Input>();
20            input.0 = line.unwrap();
21        }
22        app.update();
23
24        if let Some(exit) = app.should_exit() {
25            return exit;
26        }
27    }
28
29    AppExit::Success
30}
More examples
Hide additional examples
examples/ecs/send_and_receive_events.rs (line 44)
24fn main() {
25    let mut app = App::new();
26    app.add_plugins(MinimalPlugins)
27        .add_event::<DebugEvent>()
28        .add_event::<A>()
29        .add_event::<B>()
30        .add_systems(Update, read_and_write_different_event_types)
31        .add_systems(
32            Update,
33            (
34                send_events,
35                debug_events,
36                send_and_receive_param_set,
37                debug_events,
38                send_and_receive_manual_event_reader,
39                debug_events,
40            )
41                .chain(),
42        );
43    // We're just going to run a few frames, so we can see and understand the output.
44    app.update();
45    // By running for longer than one frame, we can see that we're caching our cursor in the event queue properly.
46    app.update();
47}
tests/ecs/ambiguity_detection.rs (line 31)
14fn main() {
15    let mut app = App::new();
16    app.add_plugins(DefaultPlugins);
17
18    let main_app = app.main_mut();
19    configure_ambiguity_detection(main_app);
20    let render_extract_app = app.sub_app_mut(RenderExtractApp);
21    configure_ambiguity_detection(render_extract_app);
22
23    // Ambiguities in the RenderApp are currently allowed.
24    // Eventually, we should forbid these: see https://github.com/bevyengine/bevy/issues/7386
25    // Uncomment the lines below to show the current ambiguities in the RenderApp.
26    // let sub_app = app.sub_app_mut(bevy_render::RenderApp);
27    // configure_ambiguity_detection(sub_app);
28
29    app.finish();
30    app.cleanup();
31    app.update();
32
33    let main_app_ambiguities = count_ambiguities(app.main());
34    assert_eq!(
35        main_app_ambiguities.total(),
36        0,
37        "Main app has unexpected ambiguities among the following schedules: \n{main_app_ambiguities:#?}.",
38    );
39
40    // RenderApp is not checked here, because it is not within the App at this point.
41    let render_extract_ambiguities = count_ambiguities(app.sub_app(RenderExtractApp));
42    assert_eq!(
43        render_extract_ambiguities.total(),
44        0,
45        "RenderExtract app has unexpected ambiguities among the following schedules: \n{render_extract_ambiguities:#?}",
46    );
47}
examples/time/time.rs (line 46)
35fn runner(mut app: App) -> AppExit {
36    banner();
37    help();
38    let stdin = io::stdin();
39    for line in stdin.lock().lines() {
40        if let Err(err) = line {
41            println!("read err: {err:#}");
42            break;
43        }
44        match line.unwrap().as_str() {
45            "" => {
46                app.update();
47            }
48            "f" => {
49                println!("FAST: setting relative speed to 2x");
50                app.world_mut()
51                    .resource_mut::<Time<Virtual>>()
52                    .set_relative_speed(2.0);
53            }
54            "n" => {
55                println!("NORMAL: setting relative speed to 1x");
56                app.world_mut()
57                    .resource_mut::<Time<Virtual>>()
58                    .set_relative_speed(1.0);
59            }
60            "s" => {
61                println!("SLOW: setting relative speed to 0.5x");
62                app.world_mut()
63                    .resource_mut::<Time<Virtual>>()
64                    .set_relative_speed(0.5);
65            }
66            "p" => {
67                println!("PAUSE: pausing virtual clock");
68                app.world_mut().resource_mut::<Time<Virtual>>().pause();
69            }
70            "u" => {
71                println!("UNPAUSE: resuming virtual clock");
72                app.world_mut().resource_mut::<Time<Virtual>>().unpause();
73            }
74            "q" => {
75                println!("QUITTING!");
76                break;
77            }
78            _ => {
79                help();
80            }
81        }
82    }
83
84    AppExit::Success
85}
examples/ecs/system_stepping.rs (line 38)
7fn main() {
8    let mut app = App::new();
9
10    app
11        // to display log messages from Stepping resource
12        .add_plugins(LogPlugin::default())
13        .add_systems(
14            Update,
15            (
16                update_system_one,
17                // establish a dependency here to simplify descriptions below
18                update_system_two.after(update_system_one),
19                update_system_three.after(update_system_two),
20                update_system_four,
21            ),
22        )
23        .add_systems(PreUpdate, pre_update_system);
24
25    // For the simplicity of this example, we directly modify the `Stepping`
26    // resource here and run the systems with `App::update()`.  Each call to
27    // `App::update()` is the equivalent of a single frame render when using
28    // `App::run()`.
29    //
30    // In a real-world situation, the `Stepping` resource would be modified by
31    // a system based on input from the user.  A full demonstration of this can
32    // be found in the breakout example.
33    println!(
34        r#"
35    Actions: call app.update()
36     Result: All systems run normally"#
37    );
38    app.update();
39
40    println!(
41        r#"
42    Actions: Add the Stepping resource then call app.update()
43     Result: All systems run normally.  Stepping has no effect unless explicitly
44             configured for a Schedule, and Stepping has been enabled."#
45    );
46    app.insert_resource(Stepping::new());
47    app.update();
48
49    println!(
50        r#"
51    Actions: Add the Update Schedule to Stepping; enable Stepping; call
52             app.update()
53     Result: Only the systems in PreUpdate run.  When Stepping is enabled,
54             systems in the configured schedules will not run unless:
55             * Stepping::step_frame() is called
56             * Stepping::continue_frame() is called
57             * System has been configured to always run"#
58    );
59    let mut stepping = app.world_mut().resource_mut::<Stepping>();
60    stepping.add_schedule(Update).enable();
61    app.update();
62
63    println!(
64        r#"
65    Actions: call Stepping.step_frame(); call app.update()
66     Result: The PreUpdate systems run, and one Update system will run.  In
67             Stepping, step means run the next system across all the schedules 
68             that have been added to the Stepping resource."#
69    );
70    let mut stepping = app.world_mut().resource_mut::<Stepping>();
71    stepping.step_frame();
72    app.update();
73
74    println!(
75        r#"
76    Actions: call app.update()
77     Result: Only the PreUpdate systems run.  The previous call to
78             Stepping::step_frame() only applies for the next call to
79             app.update()/the next frame rendered.
80    "#
81    );
82    app.update();
83
84    println!(
85        r#"
86    Actions: call Stepping::continue_frame(); call app.update()
87     Result: PreUpdate system will run, and all remaining Update systems will
88             run.  Stepping::continue_frame() tells stepping to run all systems
89             starting after the last run system until it hits the end of the
90             frame, or it encounters a system with a breakpoint set.  In this
91             case, we previously performed a step, running one system in Update.
92             This continue will cause all remaining systems in Update to run."#
93    );
94    let mut stepping = app.world_mut().resource_mut::<Stepping>();
95    stepping.continue_frame();
96    app.update();
97
98    println!(
99        r#"
100    Actions: call Stepping::step_frame() & app.update() four times in a row
101     Result: PreUpdate system runs every time we call app.update(), along with
102             one system from the Update schedule each time.  This shows what
103             execution would look like to step through an entire frame of 
104             systems."#
105    );
106    for _ in 0..4 {
107        let mut stepping = app.world_mut().resource_mut::<Stepping>();
108        stepping.step_frame();
109        app.update();
110    }
111
112    println!(
113        r#"
114    Actions: Stepping::always_run(Update, update_system_two); step through all
115             systems
116     Result: PreUpdate system and update_system_two() will run every time we
117             call app.update().  We'll also only need to step three times to
118             execute all systems in the frame.  Stepping::always_run() allows
119             us to granularly allow systems to run when stepping is enabled."#
120    );
121    let mut stepping = app.world_mut().resource_mut::<Stepping>();
122    stepping.always_run(Update, update_system_two);
123    for _ in 0..3 {
124        let mut stepping = app.world_mut().resource_mut::<Stepping>();
125        stepping.step_frame();
126        app.update();
127    }
128
129    println!(
130        r#"
131    Actions: Stepping::never_run(Update, update_system_two); continue through
132             all systems
133     Result: All systems except update_system_two() will execute.
134             Stepping::never_run() allows us to disable systems while Stepping
135             is enabled."#
136    );
137    let mut stepping = app.world_mut().resource_mut::<Stepping>();
138    stepping.never_run(Update, update_system_two);
139    stepping.continue_frame();
140    app.update();
141
142    println!(
143        r#"
144    Actions: Stepping::set_breakpoint(Update, update_system_two); continue,
145             step, continue
146     Result: During the first continue, pre_update_system() and
147             update_system_one() will run.  update_system_four() may also run
148             as it has no dependency on update_system_two() or
149             update_system_three().  Nether update_system_two() nor
150             update_system_three() will run in the first app.update() call as
151             they form a chained dependency on update_system_one() and run
152             in order of one, two, three.  Stepping stops system execution in
153             the Update schedule when it encounters the breakpoint for
154             update_system_three().
155             During the step we run update_system_two() along with the
156             pre_update_system().
157             During the final continue pre_update_system() and
158             update_system_three() run."#
159    );
160    let mut stepping = app.world_mut().resource_mut::<Stepping>();
161    stepping.set_breakpoint(Update, update_system_two);
162    stepping.continue_frame();
163    app.update();
164    let mut stepping = app.world_mut().resource_mut::<Stepping>();
165    stepping.step_frame();
166    app.update();
167    let mut stepping = app.world_mut().resource_mut::<Stepping>();
168    stepping.continue_frame();
169    app.update();
170
171    println!(
172        r#"
173    Actions: Stepping::clear_breakpoint(Update, update_system_two); continue
174             through all systems
175     Result: All systems will run"#
176    );
177    let mut stepping = app.world_mut().resource_mut::<Stepping>();
178    stepping.clear_breakpoint(Update, update_system_two);
179    stepping.continue_frame();
180    app.update();
181
182    println!(
183        r#"
184    Actions: Stepping::disable(); app.update()
185     Result: All systems will run.  With Stepping disabled, there's no need to
186             call Stepping::step_frame() or Stepping::continue_frame() to run
187             systems in the Update schedule."#
188    );
189    let mut stepping = app.world_mut().resource_mut::<Stepping>();
190    stepping.disable();
191    app.update();
192}
Source

pub fn run(&mut self) -> AppExit

Runs the App by calling its runner.

This will (re)build the App first. For general usage, see the example on the item level documentation.

§Caveats

Calls to App::run() will never return on iOS and Web.

Headless apps can generally expect this method to return control to the caller when it completes, but that is not the case for windowed apps. Windowed apps are typically driven by an event loop and some platforms expect the program to terminate when the event loop ends.

By default, Bevy uses the winit crate for window creation.

§Panics

Panics if not all plugins have been built.

Examples found in repository?
examples/app/empty.rs (line 6)
5fn main() {
6    App::new().run();
7}
More examples
Hide additional examples
examples/app/empty_defaults.rs (line 6)
5fn main() {
6    App::new().add_plugins(DefaultPlugins).run();
7}
examples/hello_world.rs (line 6)
5fn main() {
6    App::new().add_systems(Update, hello_world_system).run();
7}
examples/2d/mesh2d.rs (line 9)
5fn main() {
6    App::new()
7        .add_plugins(DefaultPlugins)
8        .add_systems(Startup, setup)
9        .run();
10}
examples/2d/mesh2d_alpha_mode.rs (line 14)
10fn main() {
11    App::new()
12        .add_plugins(DefaultPlugins)
13        .add_systems(Startup, setup)
14        .run();
15}
examples/2d/mesh2d_vertex_color_texture.rs (line 10)
6fn main() {
7    App::new()
8        .add_plugins(DefaultPlugins)
9        .add_systems(Startup, setup)
10        .run();
11}
Additional examples can be found in:
Source

pub fn set_runner( &mut self, f: impl FnOnce(App) -> AppExit + 'static, ) -> &mut App

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

The runner function f 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) -> AppExit {
    loop {
        println!("In main loop");
        app.update();
        if let Some(exit) = app.should_exit() {
            return exit;
        }
    }
}

App::new()
    .set_runner(my_runner);
Examples found in repository?
examples/app/custom_loop.rs (line 46)
43fn main() -> AppExit {
44    App::new()
45        .insert_resource(Input(String::new()))
46        .set_runner(my_runner)
47        .add_systems(Update, (print_system, exit_system))
48        .run()
49}
More examples
Hide additional examples
examples/time/time.rs (line 119)
111fn main() {
112    App::new()
113        .add_plugins(MinimalPlugins)
114        .insert_resource(Time::<Virtual>::from_max_delta(Duration::from_secs(5)))
115        .insert_resource(Time::<Fixed>::from_duration(Duration::from_secs(1)))
116        .add_systems(PreUpdate, print_real_time)
117        .add_systems(FixedUpdate, print_fixed_time)
118        .add_systems(Update, print_time)
119        .set_runner(runner)
120        .run();
121}
Source

pub fn plugins_state(&mut self) -> PluginsState

Returns the state of all plugins. This is usually called by the event loop, but can be useful for situations where you want to use App::update.

Source

pub fn finish(&mut self)

Runs Plugin::finish for each plugin. This is usually called by the event loop once all plugins are ready, but can be useful for situations where you want to use App::update.

Examples found in repository?
examples/app/custom_loop.rs (line 13)
10fn my_runner(mut app: App) -> AppExit {
11    // Finalize plugin building, including running any necessary clean-up.
12    // This is normally completed by the default runner.
13    app.finish();
14    app.cleanup();
15
16    println!("Type stuff into the console");
17    for line in io::stdin().lines() {
18        {
19            let mut input = app.world_mut().resource_mut::<Input>();
20            input.0 = line.unwrap();
21        }
22        app.update();
23
24        if let Some(exit) = app.should_exit() {
25            return exit;
26        }
27    }
28
29    AppExit::Success
30}
More examples
Hide additional examples
tests/ecs/ambiguity_detection.rs (line 29)
14fn main() {
15    let mut app = App::new();
16    app.add_plugins(DefaultPlugins);
17
18    let main_app = app.main_mut();
19    configure_ambiguity_detection(main_app);
20    let render_extract_app = app.sub_app_mut(RenderExtractApp);
21    configure_ambiguity_detection(render_extract_app);
22
23    // Ambiguities in the RenderApp are currently allowed.
24    // Eventually, we should forbid these: see https://github.com/bevyengine/bevy/issues/7386
25    // Uncomment the lines below to show the current ambiguities in the RenderApp.
26    // let sub_app = app.sub_app_mut(bevy_render::RenderApp);
27    // configure_ambiguity_detection(sub_app);
28
29    app.finish();
30    app.cleanup();
31    app.update();
32
33    let main_app_ambiguities = count_ambiguities(app.main());
34    assert_eq!(
35        main_app_ambiguities.total(),
36        0,
37        "Main app has unexpected ambiguities among the following schedules: \n{main_app_ambiguities:#?}.",
38    );
39
40    // RenderApp is not checked here, because it is not within the App at this point.
41    let render_extract_ambiguities = count_ambiguities(app.sub_app(RenderExtractApp));
42    assert_eq!(
43        render_extract_ambiguities.total(),
44        0,
45        "RenderExtract app has unexpected ambiguities among the following schedules: \n{render_extract_ambiguities:#?}",
46    );
47}
Source

pub fn cleanup(&mut self)

Runs Plugin::cleanup for each plugin. This is usually called by the event loop after App::finish, but can be useful for situations where you want to use App::update.

Examples found in repository?
examples/app/custom_loop.rs (line 14)
10fn my_runner(mut app: App) -> AppExit {
11    // Finalize plugin building, including running any necessary clean-up.
12    // This is normally completed by the default runner.
13    app.finish();
14    app.cleanup();
15
16    println!("Type stuff into the console");
17    for line in io::stdin().lines() {
18        {
19            let mut input = app.world_mut().resource_mut::<Input>();
20            input.0 = line.unwrap();
21        }
22        app.update();
23
24        if let Some(exit) = app.should_exit() {
25            return exit;
26        }
27    }
28
29    AppExit::Success
30}
More examples
Hide additional examples
tests/ecs/ambiguity_detection.rs (line 30)
14fn main() {
15    let mut app = App::new();
16    app.add_plugins(DefaultPlugins);
17
18    let main_app = app.main_mut();
19    configure_ambiguity_detection(main_app);
20    let render_extract_app = app.sub_app_mut(RenderExtractApp);
21    configure_ambiguity_detection(render_extract_app);
22
23    // Ambiguities in the RenderApp are currently allowed.
24    // Eventually, we should forbid these: see https://github.com/bevyengine/bevy/issues/7386
25    // Uncomment the lines below to show the current ambiguities in the RenderApp.
26    // let sub_app = app.sub_app_mut(bevy_render::RenderApp);
27    // configure_ambiguity_detection(sub_app);
28
29    app.finish();
30    app.cleanup();
31    app.update();
32
33    let main_app_ambiguities = count_ambiguities(app.main());
34    assert_eq!(
35        main_app_ambiguities.total(),
36        0,
37        "Main app has unexpected ambiguities among the following schedules: \n{main_app_ambiguities:#?}.",
38    );
39
40    // RenderApp is not checked here, because it is not within the App at this point.
41    let render_extract_ambiguities = count_ambiguities(app.sub_app(RenderExtractApp));
42    assert_eq!(
43        render_extract_ambiguities.total(),
44        0,
45        "RenderExtract app has unexpected ambiguities among the following schedules: \n{render_extract_ambiguities:#?}",
46    );
47}
Source

pub fn add_systems<M>( &mut self, schedule: impl ScheduleLabel, systems: impl IntoScheduleConfigs<Box<dyn System<Out = Result<(), BevyError>, In = ()>>, M>, ) -> &mut App

Adds one or more systems to the given schedule in this app’s Schedules.

§Examples
app.add_systems(Update, (system_a, system_b, system_c));
app.add_systems(Update, (system_a, system_b).run_if(should_run));
Examples found in repository?
examples/hello_world.rs (line 6)
5fn main() {
6    App::new().add_systems(Update, hello_world_system).run();
7}
More examples
Hide additional examples
examples/app/plugin_group.rs (line 41)
40    fn build(&self, app: &mut App) {
41        app.add_systems(Update, print_hello_system);
42    }
43}
44
45fn print_hello_system() {
46    info!("hello");
47}
48
49struct PrintWorldPlugin;
50
51impl Plugin for PrintWorldPlugin {
52    fn build(&self, app: &mut App) {
53        app.add_systems(Update, print_world_system);
54    }
examples/3d/../helpers/camera_controller.rs (line 20)
19    fn build(&self, app: &mut App) {
20        app.add_systems(Update, run_camera_controller);
21    }
examples/2d/mesh2d.rs (line 8)
5fn main() {
6    App::new()
7        .add_plugins(DefaultPlugins)
8        .add_systems(Startup, setup)
9        .run();
10}
examples/2d/mesh2d_alpha_mode.rs (line 13)
10fn main() {
11    App::new()
12        .add_plugins(DefaultPlugins)
13        .add_systems(Startup, setup)
14        .run();
15}
examples/2d/mesh2d_vertex_color_texture.rs (line 9)
6fn main() {
7    App::new()
8        .add_plugins(DefaultPlugins)
9        .add_systems(Startup, setup)
10        .run();
11}
Additional examples can be found in:
Source

pub fn register_system<I, O, M>( &mut self, system: impl IntoSystem<I, O, M> + 'static, ) -> SystemId<I, O>
where I: SystemInput + 'static, O: 'static,

Registers a system and returns a SystemId so it can later be called by World::run_system.

It’s possible to register the same systems more than once, they’ll be stored separately.

This is different from adding systems to a Schedule with App::add_systems, because the SystemId that is returned can be used anywhere in the World to run the associated system. This allows for running systems in a push-based fashion. Using a Schedule is still preferred for most cases due to its better performance and ability to run non-conflicting systems simultaneously.

Source

pub fn configure_sets<M>( &mut self, schedule: impl ScheduleLabel, sets: impl IntoScheduleConfigs<Interned<dyn SystemSet>, M>, ) -> &mut App

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

Examples found in repository?
examples/ecs/ecs_guide.rs (lines 330-334)
293fn main() {
294    // Bevy apps are created using the builder pattern. We use the builder to add systems,
295    // resources, and plugins to our app
296    App::new()
297        // Resources that implement the Default or FromWorld trait can be added like this:
298        .init_resource::<GameState>()
299        // Plugins are just a grouped set of app builder calls (just like we're doing here).
300        // We could easily turn our game into a plugin, but you can check out the plugin example for
301        // that :) The plugin below runs our app's "system schedule" once every 5 seconds.
302        .add_plugins(ScheduleRunnerPlugin::run_loop(Duration::from_secs(5)))
303        // `Startup` systems run exactly once BEFORE all other systems. These are generally used for
304        // app initialization code (ex: adding entities and resources)
305        .add_systems(Startup, startup_system)
306        // `Update` systems run once every update. These are generally used for "real-time app logic"
307        .add_systems(Update, print_message_system)
308        // SYSTEM EXECUTION ORDER
309        //
310        // Each system belongs to a `Schedule`, which controls the execution strategy and broad order
311        // of the systems within each tick. The `Startup` schedule holds
312        // startup systems, which are run a single time before `Update` runs. `Update` runs once per app update,
313        // which is generally one "frame" or one "tick".
314        //
315        // By default, all systems in a `Schedule` run in parallel, except when they require mutable access to a
316        // piece of data. This is efficient, but sometimes order matters.
317        // For example, we want our "game over" system to execute after all other systems to ensure
318        // we don't accidentally run the game for an extra round.
319        //
320        // You can force an explicit ordering between systems using the `.before` or `.after` methods.
321        // Systems will not be scheduled until all of the systems that they have an "ordering dependency" on have
322        // completed.
323        // There are other schedules, such as `Last` which runs at the very end of each run.
324        .add_systems(Last, print_at_end_round)
325        // We can also create new system sets, and order them relative to other system sets.
326        // Here is what our games execution order will look like:
327        // "before_round": new_player_system, new_round_system
328        // "round": print_message_system, score_system
329        // "after_round": score_check_system, game_over_system
330        .configure_sets(
331            Update,
332            // chain() will ensure sets run in the order they are listed
333            (MySet::BeforeRound, MySet::Round, MySet::AfterRound).chain(),
334        )
335        // The add_systems function is powerful. You can define complex system configurations with ease!
336        .add_systems(
337            Update,
338            (
339                // These `BeforeRound` systems will run before `Round` systems, thanks to the chained set configuration
340                (
341                    // You can also chain systems! new_round_system will run first, followed by new_player_system
342                    (new_round_system, new_player_system).chain(),
343                    exclusive_player_system,
344                )
345                    // All of the systems in the tuple above will be added to this set
346                    .in_set(MySet::BeforeRound),
347                // This `Round` system will run after the `BeforeRound` systems thanks to the chained set configuration
348                score_system.in_set(MySet::Round),
349                // These `AfterRound` systems will run after the `Round` systems thanks to the chained set configuration
350                (
351                    score_check_system,
352                    // In addition to chain(), you can also use `before(system)` and `after(system)`. This also works
353                    // with sets!
354                    game_over_system.after(score_check_system),
355                )
356                    .in_set(MySet::AfterRound),
357            ),
358        )
359        // This call to run() starts the app we just built!
360        .run();
361}
Source

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

Initializes T event handling by inserting an event queue resource (Events::<T>) and scheduling an event_update_system in First.

See Events for information on how to define events.

§Examples
app.add_event::<MyEvent>();
Examples found in repository?
examples/audio/pitch.rs (line 9)
6fn main() {
7    App::new()
8        .add_plugins(DefaultPlugins)
9        .add_event::<PlayPitch>()
10        .add_systems(Startup, setup)
11        .add_systems(Update, (play_pitch, keyboard_input_system))
12        .run();
13}
More examples
Hide additional examples
examples/ecs/component_hooks.rs (line 56)
50fn main() {
51    App::new()
52        .add_plugins(DefaultPlugins)
53        .add_systems(Startup, setup)
54        .add_systems(Update, trigger_hooks)
55        .init_resource::<MyComponentIndex>()
56        .add_event::<MyEvent>()
57        .run();
58}
examples/ui/size_constraints.rs (line 8)
5fn main() {
6    App::new()
7        .add_plugins(DefaultPlugins)
8        .add_event::<ButtonActivatedEvent>()
9        .add_systems(Startup, setup)
10        .add_systems(Update, (update_buttons, update_radio_buttons_colors))
11        .run();
12}
examples/animation/animation_events.rs (line 12)
9fn main() {
10    App::new()
11        .add_plugins(DefaultPlugins)
12        .add_event::<MessageEvent>()
13        .add_systems(Startup, setup)
14        .add_systems(Update, animate_text_opacity)
15        .add_observer(edit_message)
16        .run();
17}
examples/async_tasks/external_source_external_thread.rs (line 11)
9fn main() {
10    App::new()
11        .add_event::<StreamEvent>()
12        .add_plugins(DefaultPlugins)
13        .add_systems(Startup, setup)
14        .add_systems(Update, (spawn_text, move_text))
15        .add_systems(FixedUpdate, read_stream)
16        .insert_resource(Time::<Fixed>::from_seconds(0.5))
17        .run();
18}
examples/app/log_layers_ecs.rs (line 106)
99fn custom_layer(app: &mut App) -> Option<BoxedLayer> {
100    let (sender, receiver) = mpsc::channel();
101
102    let layer = CaptureLayer { sender };
103    let resource = CapturedLogEvents(receiver);
104
105    app.insert_non_send_resource(resource);
106    app.add_event::<LogEvent>();
107    app.add_systems(Update, transfer_log_events);
108
109    Some(layer.boxed())
110}
Additional examples can be found in:
Source

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

Inserts the Resource into the app, overwriting any existing resource of the same type.

There is also an init_resource for resources that have Default or FromWorld implementations.

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

App::new()
   .insert_resource(MyCounter { counter: 0 });
Examples found in repository?
examples/ecs/system_param.rs (line 7)
5fn main() {
6    App::new()
7        .insert_resource(PlayerCount(0))
8        .add_systems(Startup, spawn)
9        .add_systems(Update, count_players)
10        .run();
11}
More examples
Hide additional examples
examples/ui/transparency_ui.rs (line 8)
6fn main() {
7    App::new()
8        .insert_resource(ClearColor(Color::BLACK))
9        .add_plugins(DefaultPlugins)
10        .add_systems(Startup, setup)
11        .run();
12}
examples/ui/z_index.rs (line 13)
11fn main() {
12    App::new()
13        .insert_resource(ClearColor(Color::BLACK))
14        .add_plugins(DefaultPlugins)
15        .add_systems(Startup, setup)
16        .run();
17}
examples/app/custom_loop.rs (line 45)
43fn main() -> AppExit {
44    App::new()
45        .insert_resource(Input(String::new()))
46        .set_runner(my_runner)
47        .add_systems(Update, (print_system, exit_system))
48        .run()
49}
examples/3d/mesh_ray_cast.rs (line 19)
14fn main() {
15    App::new()
16        .add_plugins(DefaultPlugins)
17        .add_systems(Startup, setup)
18        .add_systems(Update, bouncing_raycast)
19        .insert_resource(ClearColor(Color::BLACK))
20        .run();
21}
examples/ui/ghost_nodes.rs (line 17)
14fn main() {
15    App::new()
16        .add_plugins(DefaultPlugins)
17        .insert_resource(WinitSettings::desktop_app())
18        .add_systems(Startup, setup)
19        .add_systems(Update, button_system)
20        .run();
21}
Additional examples can be found in:
Source

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

Inserts the Resource, initialized with its default value, into the app, if there is no existing instance of R.

R must implement FromWorld. If R implements Default, FromWorld will be automatically implemented and initialize the Resource with Default::default.

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

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

App::new()
    .init_resource::<MyCounter>();
Examples found in repository?
examples/camera/camera_orbit.rs (line 39)
36fn main() {
37    App::new()
38        .add_plugins(DefaultPlugins)
39        .init_resource::<CameraSettings>()
40        .add_systems(Startup, (setup, instructions))
41        .add_systems(Update, orbit)
42        .run();
43}
More examples
Hide additional examples
examples/time/timers.rs (line 8)
5fn main() {
6    App::new()
7        .add_plugins(DefaultPlugins)
8        .init_resource::<Countdown>()
9        .add_systems(Startup, setup)
10        .add_systems(Update, (countdown, print_when_completed))
11        .run();
12}
examples/ecs/component_hooks.rs (line 55)
50fn main() {
51    App::new()
52        .add_plugins(DefaultPlugins)
53        .add_systems(Startup, setup)
54        .add_systems(Update, trigger_hooks)
55        .init_resource::<MyComponentIndex>()
56        .add_event::<MyEvent>()
57        .run();
58}
examples/ui/font_atlas_debug.rs (line 10)
8fn main() {
9    App::new()
10        .init_resource::<State>()
11        .insert_resource(ClearColor(Color::BLACK))
12        .add_plugins(DefaultPlugins)
13        .add_systems(Startup, setup)
14        .add_systems(Update, (text_update_system, atlas_render_system))
15        .run();
16}
examples/3d/clearcoat.rs (line 51)
49pub fn main() {
50    App::new()
51        .init_resource::<LightMode>()
52        .add_plugins(DefaultPlugins)
53        .add_systems(Startup, setup)
54        .add_systems(Update, animate_light)
55        .add_systems(Update, animate_spheres)
56        .add_systems(Update, (handle_input, update_help_text).chain())
57        .run();
58}
examples/asset/custom_asset.rs (line 95)
92fn main() {
93    App::new()
94        .add_plugins(DefaultPlugins)
95        .init_resource::<State>()
96        .init_asset::<CustomAsset>()
97        .init_asset::<Blob>()
98        .init_asset_loader::<CustomAssetLoader>()
99        .init_asset_loader::<BlobAssetLoader>()
100        .add_systems(Startup, setup)
101        .add_systems(Update, print_on_load)
102        .run();
103}
Additional examples can be found in:
Source

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

Inserts the !Send resource into the app, overwriting any existing resource of the same type.

There is also an init_non_send_resource for resources that implement Default

§Examples
struct MyCounter {
    counter: usize,
}

App::new()
    .insert_non_send_resource(MyCounter { counter: 0 });
Examples found in repository?
examples/app/log_layers_ecs.rs (line 105)
99fn custom_layer(app: &mut App) -> Option<BoxedLayer> {
100    let (sender, receiver) = mpsc::channel();
101
102    let layer = CaptureLayer { sender };
103    let resource = CapturedLogEvents(receiver);
104
105    app.insert_non_send_resource(resource);
106    app.add_event::<LogEvent>();
107    app.add_systems(Update, transfer_log_events);
108
109    Some(layer.boxed())
110}
Source

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

Inserts the !Send resource into the app if there is no existing instance of R.

R must implement FromWorld. If R implements Default, FromWorld will be automatically implemented and initialize the Resource with Default::default.

Source

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

Returns true if the Plugin has already been added.

Source

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

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

This can be used to read the settings of any existing plugins. This vector will be empty 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;
Source

pub fn add_plugins<M>(&mut self, plugins: impl Plugins<M>) -> &mut App

Installs a Plugin collection.

Bevy prioritizes modularity as a core principle. All engine features are implemented as plugins, even the complex ones like rendering.

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.

You can also specify a group of Plugins by using a tuple over Plugins and PluginGroups. See Plugins for more details.

§Examples
App::new()
    .add_plugins(MinimalPlugins);
App::new()
    .add_plugins((MinimalPlugins, LogPlugin));
§Panics

Panics if one of the plugins had already been added to the application.

Examples found in repository?
examples/app/empty_defaults.rs (line 6)
5fn main() {
6    App::new().add_plugins(DefaultPlugins).run();
7}
More examples
Hide additional examples
examples/2d/mesh2d.rs (line 7)
5fn main() {
6    App::new()
7        .add_plugins(DefaultPlugins)
8        .add_systems(Startup, setup)
9        .run();
10}
examples/2d/mesh2d_alpha_mode.rs (line 12)
10fn main() {
11    App::new()
12        .add_plugins(DefaultPlugins)
13        .add_systems(Startup, setup)
14        .run();
15}
examples/2d/mesh2d_vertex_color_texture.rs (line 8)
6fn main() {
7    App::new()
8        .add_plugins(DefaultPlugins)
9        .add_systems(Startup, setup)
10        .run();
11}
examples/2d/sprite.rs (line 7)
5fn main() {
6    App::new()
7        .add_plugins(DefaultPlugins)
8        .add_systems(Startup, setup)
9        .run();
10}
examples/2d/sprite_flipping.rs (line 7)
5fn main() {
6    App::new()
7        .add_plugins(DefaultPlugins)
8        .add_systems(Startup, setup)
9        .run();
10}
Additional examples can be found in:
Source

pub fn register_type<T>(&mut self) -> &mut App
where T: GetTypeRegistration,

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

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

See bevy_reflect::TypeRegistry::register for more information.

Examples found in repository?
examples/reflection/reflection.rs (line 20)
16fn main() {
17    App::new()
18        .add_plugins(DefaultPlugins)
19        // Bar will be automatically registered as it's a dependency of Foo
20        .register_type::<Foo>()
21        .add_systems(Startup, setup)
22        .run();
23}
More examples
Hide additional examples
examples/reflection/generic_reflection.rs (line 10)
6fn main() {
7    App::new()
8        .add_plugins(DefaultPlugins)
9        // You must manually register each instance of a generic type
10        .register_type::<MyType<u32>>()
11        .add_systems(Startup, setup)
12        .run();
13}
examples/scene/scene.rs (line 38)
35fn main() {
36    App::new()
37        .add_plugins(DefaultPlugins)
38        .register_type::<ComponentA>()
39        .register_type::<ComponentB>()
40        .register_type::<ResourceA>()
41        .add_systems(
42            Startup,
43            (save_scene_system, load_scene_system, infotext_system),
44        )
45        .add_systems(Update, (log_system, panic_on_fail))
46        .run();
47}
examples/remote/server.rs (line 20)
11fn main() {
12    App::new()
13        .add_plugins(DefaultPlugins)
14        .add_plugins(RemotePlugin::default())
15        .add_plugins(RemoteHttpPlugin::default())
16        .add_systems(Startup, setup)
17        .add_systems(Update, remove.run_if(input_just_pressed(KeyCode::Space)))
18        .add_systems(Update, move_cube)
19        // New types must be registered in order to be usable with reflection.
20        .register_type::<Cube>()
21        .register_type::<TestResource>()
22        .run();
23}
Source

pub fn register_type_data<T, D>(&mut self) -> &mut App
where T: Reflect + TypePath, D: TypeData + FromType<T>,

Associates type data D with type T in the AppTypeRegistry resource.

Most of the time 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.

Source

pub fn register_function<F, Marker>(&mut self, function: F) -> &mut App
where F: IntoFunction<'static, Marker> + 'static,

Registers the given function into the AppFunctionRegistry resource.

The given function will internally be stored as a DynamicFunction and mapped according to its name.

Because the function must have a name, anonymous functions (e.g. |a: i32, b: i32| { a + b }) and closures must instead be registered using register_function_with_name or converted to a DynamicFunction and named using DynamicFunction::with_name. Failure to do so will result in a panic.

Only types that implement IntoFunction may be registered via this method.

See FunctionRegistry::register for more information.

§Panics

Panics if a function has already been registered with the given name or if the function is missing a name (such as when it is an anonymous function).

§Examples
use bevy_app::App;

fn add(a: i32, b: i32) -> i32 {
    a + b
}

App::new().register_function(add);

Functions cannot be registered more than once.

ⓘ
use bevy_app::App;

fn add(a: i32, b: i32) -> i32 {
    a + b
}

App::new()
    .register_function(add)
    // Panic! A function has already been registered with the name "my_function"
    .register_function(add);

Anonymous functions and closures should be registered using register_function_with_name or given a name using DynamicFunction::with_name.

ⓘ
use bevy_app::App;

// Panic! Anonymous functions cannot be registered using `register_function`
App::new().register_function(|a: i32, b: i32| a + b);
Source

pub fn register_function_with_name<F, Marker>( &mut self, name: impl Into<Cow<'static, str>>, function: F, ) -> &mut App
where F: IntoFunction<'static, Marker> + 'static,

Registers the given function or closure into the AppFunctionRegistry resource using the given name.

To avoid conflicts, it’s recommended to use a unique name for the function. This can be achieved by “namespacing” the function with a unique identifier, such as the name of your crate.

For example, to register a function, add, from a crate, my_crate, you could use the name, "my_crate::add".

Another approach could be to use the type name of the function, however, it should be noted that anonymous functions do not have unique type names.

For named functions (e.g. fn add(a: i32, b: i32) -> i32 { a + b }) where a custom name is not needed, it’s recommended to use register_function instead as the generated name is guaranteed to be unique.

Only types that implement IntoFunction may be registered via this method.

See FunctionRegistry::register_with_name for more information.

§Panics

Panics if a function has already been registered with the given name.

§Examples
use bevy_app::App;

fn mul(a: i32, b: i32) -> i32 {
    a * b
}

let div = |a: i32, b: i32| a / b;

App::new()
    // Registering an anonymous function with a unique name
    .register_function_with_name("my_crate::add", |a: i32, b: i32| {
        a + b
    })
    // Registering an existing function with its type name
    .register_function_with_name(std::any::type_name_of_val(&mul), mul)
    // Registering an existing function with a custom name
    .register_function_with_name("my_crate::mul", mul)
    // Be careful not to register anonymous functions with their type name.
    // This code works but registers the function with a non-unique name like `foo::bar::{{closure}}`
    .register_function_with_name(std::any::type_name_of_val(&div), div);

Names must be unique.

ⓘ
use bevy_app::App;

fn one() {}
fn two() {}

App::new()
    .register_function_with_name("my_function", one)
    // Panic! A function has already been registered with the name "my_function"
    .register_function_with_name("my_function", two);
Source

pub fn register_required_components<T, R>(&mut self) -> &mut App
where T: Component, R: Component + Default,

Registers the given component R as a required component for T.

When T is added to an entity, R and its own required components will also be added if R was not already provided. The Default constructor will be used for the creation of R. If a custom constructor is desired, use App::register_required_components_with instead.

For the non-panicking version, see App::try_register_required_components.

Note that requirements must currently be registered before T is inserted into the world for the first time. Commonly, this is done in plugins. This limitation may be fixed in the future.

§Panics

Panics if R is already a directly required component for T, or if T has ever been added on an entity before the registration.

Indirect requirements through other components are allowed. In those cases, any existing requirements will only be overwritten if the new requirement is more specific.

§Example
#[derive(Component)]
struct A;

#[derive(Component, Default, PartialEq, Eq, Debug)]
struct B(usize);

#[derive(Component, Default, PartialEq, Eq, Debug)]
struct C(u32);

// Register B as required by A and C as required by B.
app.register_required_components::<A, B>();
app.register_required_components::<B, C>();

fn setup(mut commands: Commands) {
    // This will implicitly also insert B and C with their Default constructors.
    commands.spawn(A);
}

fn validate(query: Option<Single<(&A, &B, &C)>>) {
    let (a, b, c) = query.unwrap().into_inner();
    assert_eq!(b, &B(0));
    assert_eq!(c, &C(0));
}
Source

pub fn register_required_components_with<T, R>( &mut self, constructor: fn() -> R, ) -> &mut App
where T: Component, R: Component,

Registers the given component R as a required component for T.

When T is added to an entity, R and its own required components will also be added if R was not already provided. The given constructor will be used for the creation of R. If a Default constructor is desired, use App::register_required_components instead.

For the non-panicking version, see App::try_register_required_components_with.

Note that requirements must currently be registered before T is inserted into the world for the first time. Commonly, this is done in plugins. This limitation may be fixed in the future.

§Panics

Panics if R is already a directly required component for T, or if T has ever been added on an entity before the registration.

Indirect requirements through other components are allowed. In those cases, any existing requirements will only be overwritten if the new requirement is more specific.

§Example
#[derive(Component)]
struct A;

#[derive(Component, Default, PartialEq, Eq, Debug)]
struct B(usize);

#[derive(Component, Default, PartialEq, Eq, Debug)]
struct C(u32);

// Register B and C as required by A and C as required by B.
// A requiring C directly will overwrite the indirect requirement through B.
app.register_required_components::<A, B>();
app.register_required_components_with::<B, C>(|| C(1));
app.register_required_components_with::<A, C>(|| C(2));

fn setup(mut commands: Commands) {
    // This will implicitly also insert B with its Default constructor and C
    // with the custom constructor defined by A.
    commands.spawn(A);
}

fn validate(query: Option<Single<(&A, &B, &C)>>) {
    let (a, b, c) = query.unwrap().into_inner();
    assert_eq!(b, &B(0));
    assert_eq!(c, &C(2));
}
Source

pub fn try_register_required_components<T, R>( &mut self, ) -> Result<(), RequiredComponentsError>
where T: Component, R: Component + Default,

Tries to register the given component R as a required component for T.

When T is added to an entity, R and its own required components will also be added if R was not already provided. The Default constructor will be used for the creation of R. If a custom constructor is desired, use App::register_required_components_with instead.

For the panicking version, see App::register_required_components.

Note that requirements must currently be registered before T is inserted into the world for the first time. Commonly, this is done in plugins. This limitation may be fixed in the future.

§Errors

Returns a RequiredComponentsError if R is already a directly required component for T, or if T has ever been added on an entity before the registration.

Indirect requirements through other components are allowed. In those cases, any existing requirements will only be overwritten if the new requirement is more specific.

§Example
#[derive(Component)]
struct A;

#[derive(Component, Default, PartialEq, Eq, Debug)]
struct B(usize);

#[derive(Component, Default, PartialEq, Eq, Debug)]
struct C(u32);

// Register B as required by A and C as required by B.
app.register_required_components::<A, B>();
app.register_required_components::<B, C>();

// Duplicate registration! This will fail.
assert!(app.try_register_required_components::<A, B>().is_err());

fn setup(mut commands: Commands) {
    // This will implicitly also insert B and C with their Default constructors.
    commands.spawn(A);
}

fn validate(query: Option<Single<(&A, &B, &C)>>) {
    let (a, b, c) = query.unwrap().into_inner();
    assert_eq!(b, &B(0));
    assert_eq!(c, &C(0));
}
Source

pub fn try_register_required_components_with<T, R>( &mut self, constructor: fn() -> R, ) -> Result<(), RequiredComponentsError>
where T: Component, R: Component,

Tries to register the given component R as a required component for T.

When T is added to an entity, R and its own required components will also be added if R was not already provided. The given constructor will be used for the creation of R. If a Default constructor is desired, use App::register_required_components instead.

For the panicking version, see App::register_required_components_with.

Note that requirements must currently be registered before T is inserted into the world for the first time. Commonly, this is done in plugins. This limitation may be fixed in the future.

§Errors

Returns a RequiredComponentsError if R is already a directly required component for T, or if T has ever been added on an entity before the registration.

Indirect requirements through other components are allowed. In those cases, any existing requirements will only be overwritten if the new requirement is more specific.

§Example
#[derive(Component)]
struct A;

#[derive(Component, Default, PartialEq, Eq, Debug)]
struct B(usize);

#[derive(Component, Default, PartialEq, Eq, Debug)]
struct C(u32);

// Register B and C as required by A and C as required by B.
// A requiring C directly will overwrite the indirect requirement through B.
app.register_required_components::<A, B>();
app.register_required_components_with::<B, C>(|| C(1));
app.register_required_components_with::<A, C>(|| C(2));

// Duplicate registration! Even if the constructors were different, this would fail.
assert!(app.try_register_required_components_with::<B, C>(|| C(1)).is_err());

fn setup(mut commands: Commands) {
    // This will implicitly also insert B with its Default constructor and C
    // with the custom constructor defined by A.
    commands.spawn(A);
}

fn validate(query: Option<Single<(&A, &B, &C)>>) {
    let (a, b, c) = query.unwrap().into_inner();
    assert_eq!(b, &B(0));
    assert_eq!(c, &C(2));
}
Source

pub fn register_disabling_component<C>(&mut self)
where C: Component,

Registers a component type as “disabling”, using default query filters to exclude entities with the component from queries.

§Warning

As discussed in the module docs, this can have performance implications, as well as create interoperability issues, and should be used with caution.

Source

pub fn world(&self) -> &World

Returns a reference to the main SubApp’s World. This is the same as calling app.main().world().

Source

pub fn world_mut(&mut self) -> &mut World

Returns a mutable reference to the main SubApp’s World. This is the same as calling app.main_mut().world_mut().

Examples found in repository?
examples/shader/shader_material_wesl.rs (line 45)
43    fn build(&self, app: &mut App) {
44        let handle = app
45            .world_mut()
46            .resource_mut::<AssetServer>()
47            .load::<Shader>("shaders/util.wesl");
48        app.insert_resource(UtilityShader(handle));
49    }
More examples
Hide additional examples
examples/app/custom_loop.rs (line 19)
10fn my_runner(mut app: App) -> AppExit {
11    // Finalize plugin building, including running any necessary clean-up.
12    // This is normally completed by the default runner.
13    app.finish();
14    app.cleanup();
15
16    println!("Type stuff into the console");
17    for line in io::stdin().lines() {
18        {
19            let mut input = app.world_mut().resource_mut::<Input>();
20            input.0 = line.unwrap();
21        }
22        app.update();
23
24        if let Some(exit) = app.should_exit() {
25            return exit;
26        }
27    }
28
29    AppExit::Success
30}
examples/3d/occlusion_culling.rs (line 255)
248    fn finish(&self, app: &mut App) {
249        // Create the `SavedIndirectParameters` resource that we're going to use
250        // to communicate between the thread that the GPU-to-CPU readback
251        // callback runs on and the main application threads. This resource is
252        // atomically reference counted. We store one reference to the
253        // `SavedIndirectParameters` in the main app and another reference in
254        // the render app.
255        let saved_indirect_parameters = SavedIndirectParameters::from_world(app.world_mut());
256        app.insert_resource(saved_indirect_parameters.clone());
257
258        // Fetch the render app.
259        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
260            return;
261        };
262
263        render_app
264            // Insert another reference to the `SavedIndirectParameters`.
265            .insert_resource(saved_indirect_parameters);
266    }
examples/2d/mesh2d_manual.rs (line 299)
297    fn build(&self, app: &mut App) {
298        // Load our custom shader
299        let mut shaders = app.world_mut().resource_mut::<Assets<Shader>>();
300        shaders.insert(
301            &COLORED_MESH2D_SHADER_HANDLE,
302            Shader::from_wgsl(COLORED_MESH2D_SHADER, file!()),
303        );
304        app.add_plugins(SyncComponentPlugin::<ColoredMesh2d>::default());
305
306        // Register our custom draw function, and add our render systems
307        app.get_sub_app_mut(RenderApp)
308            .unwrap()
309            .add_render_command::<Transparent2d, DrawColoredMesh2d>()
310            .init_resource::<SpecializedRenderPipelines<ColoredMesh2dPipeline>>()
311            .init_resource::<RenderColoredMesh2dInstances>()
312            .add_systems(
313                ExtractSchedule,
314                extract_colored_mesh2d.after(extract_mesh2d),
315            )
316            .add_systems(Render, queue_colored_mesh2d.in_set(RenderSet::QueueMeshes));
317    }
examples/games/stepping.rs (line 44)
34    fn build(&self, app: &mut App) {
35        app.add_systems(Startup, build_stepping_hint);
36        if cfg!(not(feature = "bevy_debug_stepping")) {
37            return;
38        }
39
40        // create and insert our debug schedule into the main schedule order.
41        // We need an independent schedule so we have access to all other
42        // schedules through the `Stepping` resource
43        app.init_schedule(DebugSchedule);
44        let mut order = app.world_mut().resource_mut::<MainScheduleOrder>();
45        order.insert_after(Update, DebugSchedule);
46
47        // create our stepping resource
48        let mut stepping = Stepping::new();
49        for label in &self.schedule_labels {
50            stepping.add_schedule(*label);
51        }
52        app.insert_resource(stepping);
53
54        // add our startup & stepping systems
55        app.insert_resource(State {
56            ui_top: self.top,
57            ui_left: self.left,
58            systems: Vec::new(),
59        })
60        .add_systems(
61            DebugSchedule,
62            (
63                build_ui.run_if(not(initialized)),
64                handle_input,
65                update_ui.run_if(initialized),
66            )
67                .chain(),
68        );
69    }
examples/time/time.rs (line 50)
35fn runner(mut app: App) -> AppExit {
36    banner();
37    help();
38    let stdin = io::stdin();
39    for line in stdin.lock().lines() {
40        if let Err(err) = line {
41            println!("read err: {err:#}");
42            break;
43        }
44        match line.unwrap().as_str() {
45            "" => {
46                app.update();
47            }
48            "f" => {
49                println!("FAST: setting relative speed to 2x");
50                app.world_mut()
51                    .resource_mut::<Time<Virtual>>()
52                    .set_relative_speed(2.0);
53            }
54            "n" => {
55                println!("NORMAL: setting relative speed to 1x");
56                app.world_mut()
57                    .resource_mut::<Time<Virtual>>()
58                    .set_relative_speed(1.0);
59            }
60            "s" => {
61                println!("SLOW: setting relative speed to 0.5x");
62                app.world_mut()
63                    .resource_mut::<Time<Virtual>>()
64                    .set_relative_speed(0.5);
65            }
66            "p" => {
67                println!("PAUSE: pausing virtual clock");
68                app.world_mut().resource_mut::<Time<Virtual>>().pause();
69            }
70            "u" => {
71                println!("UNPAUSE: resuming virtual clock");
72                app.world_mut().resource_mut::<Time<Virtual>>().unpause();
73            }
74            "q" => {
75                println!("QUITTING!");
76                break;
77            }
78            _ => {
79                help();
80            }
81        }
82    }
83
84    AppExit::Success
85}
Additional examples can be found in:
Source

pub fn main(&self) -> &SubApp

Returns a reference to the main SubApp.

Examples found in repository?
tests/ecs/ambiguity_detection.rs (line 33)
14fn main() {
15    let mut app = App::new();
16    app.add_plugins(DefaultPlugins);
17
18    let main_app = app.main_mut();
19    configure_ambiguity_detection(main_app);
20    let render_extract_app = app.sub_app_mut(RenderExtractApp);
21    configure_ambiguity_detection(render_extract_app);
22
23    // Ambiguities in the RenderApp are currently allowed.
24    // Eventually, we should forbid these: see https://github.com/bevyengine/bevy/issues/7386
25    // Uncomment the lines below to show the current ambiguities in the RenderApp.
26    // let sub_app = app.sub_app_mut(bevy_render::RenderApp);
27    // configure_ambiguity_detection(sub_app);
28
29    app.finish();
30    app.cleanup();
31    app.update();
32
33    let main_app_ambiguities = count_ambiguities(app.main());
34    assert_eq!(
35        main_app_ambiguities.total(),
36        0,
37        "Main app has unexpected ambiguities among the following schedules: \n{main_app_ambiguities:#?}.",
38    );
39
40    // RenderApp is not checked here, because it is not within the App at this point.
41    let render_extract_ambiguities = count_ambiguities(app.sub_app(RenderExtractApp));
42    assert_eq!(
43        render_extract_ambiguities.total(),
44        0,
45        "RenderExtract app has unexpected ambiguities among the following schedules: \n{render_extract_ambiguities:#?}",
46    );
47}
Source

pub fn main_mut(&mut self) -> &mut SubApp

Returns a mutable reference to the main SubApp.

Examples found in repository?
tests/ecs/ambiguity_detection.rs (line 18)
14fn main() {
15    let mut app = App::new();
16    app.add_plugins(DefaultPlugins);
17
18    let main_app = app.main_mut();
19    configure_ambiguity_detection(main_app);
20    let render_extract_app = app.sub_app_mut(RenderExtractApp);
21    configure_ambiguity_detection(render_extract_app);
22
23    // Ambiguities in the RenderApp are currently allowed.
24    // Eventually, we should forbid these: see https://github.com/bevyengine/bevy/issues/7386
25    // Uncomment the lines below to show the current ambiguities in the RenderApp.
26    // let sub_app = app.sub_app_mut(bevy_render::RenderApp);
27    // configure_ambiguity_detection(sub_app);
28
29    app.finish();
30    app.cleanup();
31    app.update();
32
33    let main_app_ambiguities = count_ambiguities(app.main());
34    assert_eq!(
35        main_app_ambiguities.total(),
36        0,
37        "Main app has unexpected ambiguities among the following schedules: \n{main_app_ambiguities:#?}.",
38    );
39
40    // RenderApp is not checked here, because it is not within the App at this point.
41    let render_extract_ambiguities = count_ambiguities(app.sub_app(RenderExtractApp));
42    assert_eq!(
43        render_extract_ambiguities.total(),
44        0,
45        "RenderExtract app has unexpected ambiguities among the following schedules: \n{render_extract_ambiguities:#?}",
46    );
47}
Source

pub fn sub_apps(&self) -> &SubApps

Returns a reference to the SubApps collection.

Source

pub fn sub_apps_mut(&mut self) -> &mut SubApps

Returns a mutable reference to the SubApps collection.

Source

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

Returns a reference to the SubApp with the given label.

§Panics

Panics if the SubApp doesn’t exist.

Examples found in repository?
tests/ecs/ambiguity_detection.rs (line 41)
14fn main() {
15    let mut app = App::new();
16    app.add_plugins(DefaultPlugins);
17
18    let main_app = app.main_mut();
19    configure_ambiguity_detection(main_app);
20    let render_extract_app = app.sub_app_mut(RenderExtractApp);
21    configure_ambiguity_detection(render_extract_app);
22
23    // Ambiguities in the RenderApp are currently allowed.
24    // Eventually, we should forbid these: see https://github.com/bevyengine/bevy/issues/7386
25    // Uncomment the lines below to show the current ambiguities in the RenderApp.
26    // let sub_app = app.sub_app_mut(bevy_render::RenderApp);
27    // configure_ambiguity_detection(sub_app);
28
29    app.finish();
30    app.cleanup();
31    app.update();
32
33    let main_app_ambiguities = count_ambiguities(app.main());
34    assert_eq!(
35        main_app_ambiguities.total(),
36        0,
37        "Main app has unexpected ambiguities among the following schedules: \n{main_app_ambiguities:#?}.",
38    );
39
40    // RenderApp is not checked here, because it is not within the App at this point.
41    let render_extract_ambiguities = count_ambiguities(app.sub_app(RenderExtractApp));
42    assert_eq!(
43        render_extract_ambiguities.total(),
44        0,
45        "RenderExtract app has unexpected ambiguities among the following schedules: \n{render_extract_ambiguities:#?}",
46    );
47}
Source

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

Returns a reference to the SubApp with the given label.

§Panics

Panics if the SubApp doesn’t exist.

Examples found in repository?
examples/games/loading_screen.rs (line 291)
283        fn build(&self, app: &mut App) {
284            app.insert_resource(PipelinesReady::default());
285
286            // In order to gain access to the pipelines status, we have to
287            // go into the `RenderApp`, grab the resource from the main App
288            // and then update the pipelines status from there.
289            // Writing between these Apps can only be done through the
290            // `ExtractSchedule`.
291            app.sub_app_mut(RenderApp)
292                .add_systems(ExtractSchedule, update_pipelines_ready);
293        }
More examples
Hide additional examples
examples/shader/custom_shader_instancing.rs (line 101)
99    fn build(&self, app: &mut App) {
100        app.add_plugins(ExtractComponentPlugin::<InstanceMaterialData>::default());
101        app.sub_app_mut(RenderApp)
102            .add_render_command::<Transparent3d, DrawCustom>()
103            .init_resource::<SpecializedMeshPipelines<CustomPipeline>>()
104            .add_systems(
105                Render,
106                (
107                    queue_custom.in_set(RenderSet::QueueMeshes),
108                    prepare_instance_buffers.in_set(RenderSet::PrepareResources),
109                ),
110            );
111    }
112
113    fn finish(&self, app: &mut App) {
114        app.sub_app_mut(RenderApp).init_resource::<CustomPipeline>();
115    }
examples/shader/gpu_readback.rs (line 47)
46    fn finish(&self, app: &mut App) {
47        let render_app = app.sub_app_mut(RenderApp);
48        render_app.init_resource::<ComputePipeline>().add_systems(
49            Render,
50            prepare_bind_group
51                .in_set(RenderSet::PrepareBindGroups)
52                // We don't need to recreate the bind group every frame
53                .run_if(not(resource_exists::<GpuBufferBindGroup>)),
54        );
55
56        // Add the compute node as a top level node to the render graph
57        // This means it will only execute once per frame
58        render_app
59            .world_mut()
60            .resource_mut::<RenderGraph>()
61            .add_node(ComputeNodeLabel, ComputeNode::default());
62    }
examples/shader/compute_shader_game_of_life.rs (line 105)
101    fn build(&self, app: &mut App) {
102        // Extract the game of life image resource from the main world into the render world
103        // for operation on by the compute shader and display on the sprite.
104        app.add_plugins(ExtractResourcePlugin::<GameOfLifeImages>::default());
105        let render_app = app.sub_app_mut(RenderApp);
106        render_app.add_systems(
107            Render,
108            prepare_bind_group.in_set(RenderSet::PrepareBindGroups),
109        );
110
111        let mut render_graph = render_app.world_mut().resource_mut::<RenderGraph>();
112        render_graph.add_node(GameOfLifeLabel, GameOfLifeNode::default());
113        render_graph.add_node_edge(GameOfLifeLabel, bevy::render::graph::CameraDriverLabel);
114    }
115
116    fn finish(&self, app: &mut App) {
117        let render_app = app.sub_app_mut(RenderApp);
118        render_app.init_resource::<GameOfLifePipeline>();
119    }
examples/app/headless_renderer.rs (line 208)
203    fn build(&self, app: &mut App) {
204        let (s, r) = crossbeam_channel::unbounded();
205
206        let render_app = app
207            .insert_resource(MainWorldReceiver(r))
208            .sub_app_mut(RenderApp);
209
210        let mut graph = render_app.world_mut().resource_mut::<RenderGraph>();
211        graph.add_node(ImageCopy, ImageCopyDriver);
212        graph.add_node_edge(bevy::render::graph::CameraDriverLabel, ImageCopy);
213
214        render_app
215            .insert_resource(RenderWorldSender(s))
216            // Make ImageCopiers accessible in RenderWorld system and plugin
217            .add_systems(ExtractSchedule, image_copy_extract)
218            // Receives image data from buffer to channel
219            // so we need to run it after the render graph is done
220            .add_systems(Render, receive_image_from_buffer.after(RenderSet::Render));
221    }
tests/ecs/ambiguity_detection.rs (line 20)
14fn main() {
15    let mut app = App::new();
16    app.add_plugins(DefaultPlugins);
17
18    let main_app = app.main_mut();
19    configure_ambiguity_detection(main_app);
20    let render_extract_app = app.sub_app_mut(RenderExtractApp);
21    configure_ambiguity_detection(render_extract_app);
22
23    // Ambiguities in the RenderApp are currently allowed.
24    // Eventually, we should forbid these: see https://github.com/bevyengine/bevy/issues/7386
25    // Uncomment the lines below to show the current ambiguities in the RenderApp.
26    // let sub_app = app.sub_app_mut(bevy_render::RenderApp);
27    // configure_ambiguity_detection(sub_app);
28
29    app.finish();
30    app.cleanup();
31    app.update();
32
33    let main_app_ambiguities = count_ambiguities(app.main());
34    assert_eq!(
35        main_app_ambiguities.total(),
36        0,
37        "Main app has unexpected ambiguities among the following schedules: \n{main_app_ambiguities:#?}.",
38    );
39
40    // RenderApp is not checked here, because it is not within the App at this point.
41    let render_extract_ambiguities = count_ambiguities(app.sub_app(RenderExtractApp));
42    assert_eq!(
43        render_extract_ambiguities.total(),
44        0,
45        "RenderExtract app has unexpected ambiguities among the following schedules: \n{render_extract_ambiguities:#?}",
46    );
47}
Source

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

Returns a reference to the SubApp with the given label, if it exists.

Source

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

Returns a mutable reference to the SubApp with the given label, if it exists.

Examples found in repository?
examples/stress_tests/many_lights.rs (line 157)
156    fn build(&self, app: &mut App) {
157        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
158            return;
159        };
160
161        render_app.add_systems(Render, print_visible_light_count.in_set(RenderSet::Prepare));
162    }
More examples
Hide additional examples
examples/shader/specialized_mesh_pipeline.rs (line 113)
109    fn build(&self, app: &mut App) {
110        app.add_plugins(ExtractComponentPlugin::<CustomRenderedEntity>::default());
111
112        // We make sure to add these to the render app, not the main app.
113        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
114            return;
115        };
116        render_app
117            // This is needed to tell bevy about your custom pipeline
118            .init_resource::<SpecializedMeshPipelines<CustomMeshPipeline>>()
119            // We need to use a custom draw command so we need to register it
120            .add_render_command::<Opaque3d, DrawSpecializedPipelineCommands>()
121            .add_systems(Render, queue_custom_mesh_pipeline.in_set(RenderSet::Queue));
122    }
123
124    fn finish(&self, app: &mut App) {
125        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
126            return;
127        };
128        // Creating this pipeline needs the RenderDevice and RenderQueue
129        // which are only available once rendering plugins are initialized.
130        render_app.init_resource::<CustomMeshPipeline>();
131    }
examples/shader/custom_phase_item.rs (line 176)
169fn main() {
170    let mut app = App::new();
171    app.add_plugins(DefaultPlugins)
172        .add_plugins(ExtractComponentPlugin::<CustomRenderedEntity>::default())
173        .add_systems(Startup, setup);
174
175    // We make sure to add these to the render app, not the main app.
176    app.get_sub_app_mut(RenderApp)
177        .unwrap()
178        .init_resource::<CustomPhasePipeline>()
179        .init_resource::<SpecializedRenderPipelines<CustomPhasePipeline>>()
180        .add_render_command::<Opaque3d, DrawCustomPhaseItemCommands>()
181        .add_systems(
182            Render,
183            prepare_custom_phase_item_buffers.in_set(RenderSet::Prepare),
184        )
185        .add_systems(Render, queue_custom_phase_item.in_set(RenderSet::Queue));
186
187    app.run();
188}
examples/shader/texture_binding_array.rs (line 46)
45    fn finish(&self, app: &mut App) {
46        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
47            return;
48        };
49
50        let render_device = render_app.world().resource::<RenderDevice>();
51
52        // Check if the device support the required feature. If not, exit the example.
53        // In a real application, you should setup a fallback for the missing feature
54        if !render_device
55            .features()
56            .contains(WgpuFeatures::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING)
57        {
58            error!(
59                "Render device doesn't support feature \
60SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING, \
61which is required for texture binding arrays"
62            );
63            exit(1);
64        }
65    }
examples/2d/mesh2d_manual.rs (line 307)
297    fn build(&self, app: &mut App) {
298        // Load our custom shader
299        let mut shaders = app.world_mut().resource_mut::<Assets<Shader>>();
300        shaders.insert(
301            &COLORED_MESH2D_SHADER_HANDLE,
302            Shader::from_wgsl(COLORED_MESH2D_SHADER, file!()),
303        );
304        app.add_plugins(SyncComponentPlugin::<ColoredMesh2d>::default());
305
306        // Register our custom draw function, and add our render systems
307        app.get_sub_app_mut(RenderApp)
308            .unwrap()
309            .add_render_command::<Transparent2d, DrawColoredMesh2d>()
310            .init_resource::<SpecializedRenderPipelines<ColoredMesh2dPipeline>>()
311            .init_resource::<RenderColoredMesh2dInstances>()
312            .add_systems(
313                ExtractSchedule,
314                extract_colored_mesh2d.after(extract_mesh2d),
315            )
316            .add_systems(Render, queue_colored_mesh2d.in_set(RenderSet::QueueMeshes));
317    }
318
319    fn finish(&self, app: &mut App) {
320        // Register our custom pipeline
321        app.get_sub_app_mut(RenderApp)
322            .unwrap()
323            .init_resource::<ColoredMesh2dPipeline>();
324    }
examples/shader/custom_render_phase.rs (line 121)
115    fn build(&self, app: &mut App) {
116        app.add_plugins((
117            ExtractComponentPlugin::<DrawStencil>::default(),
118            SortedRenderPhasePlugin::<Stencil3d, MeshPipeline>::new(RenderDebugFlags::default()),
119        ));
120        // We need to get the render app from the main app
121        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
122            return;
123        };
124        render_app
125            .init_resource::<SpecializedMeshPipelines<StencilPipeline>>()
126            .init_resource::<DrawFunctions<Stencil3d>>()
127            .add_render_command::<Stencil3d, DrawMesh3dStencil>()
128            .init_resource::<ViewSortedRenderPhases<Stencil3d>>()
129            .add_systems(ExtractSchedule, extract_camera_phases)
130            .add_systems(
131                Render,
132                (
133                    queue_custom_meshes.in_set(RenderSet::QueueMeshes),
134                    sort_phase_system::<Stencil3d>.in_set(RenderSet::PhaseSort),
135                    batch_and_prepare_sorted_render_phase::<Stencil3d, StencilPipeline>
136                        .in_set(RenderSet::PrepareResources),
137                ),
138            );
139
140        render_app
141            .add_render_graph_node::<ViewNodeRunner<CustomDrawNode>>(Core3d, CustomDrawPassLabel)
142            // Tell the node to run after the main pass
143            .add_render_graph_edges(Core3d, (Node3d::MainOpaquePass, CustomDrawPassLabel));
144    }
145
146    fn finish(&self, app: &mut App) {
147        // We need to get the render app from the main app
148        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
149            return;
150        };
151        // The pipeline needs the RenderDevice to be created and it's only available once plugins
152        // are initialized
153        render_app.init_resource::<StencilPipeline>();
154    }
Additional examples can be found in:
Source

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

Inserts a SubApp with the given label.

Source

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

Removes the SubApp with the given label, if it exists.

Source

pub fn update_sub_app_by_label(&mut self, label: impl AppLabel)

Extract data from the main world into the SubApp with the given label and perform an update if it exists.

Source

pub fn add_schedule(&mut self, schedule: Schedule) -> &mut App

Inserts a new schedule under the provided label, overwriting any existing schedule with the same label.

Examples found in repository?
examples/ecs/custom_schedule.rs (line 27)
16fn main() {
17    let mut app = App::new();
18
19    // Create a new [`Schedule`]. For demonstration purposes, we configure it to use a single threaded executor so that
20    // systems in this schedule are never run in parallel. However, this is not a requirement for custom schedules in
21    // general.
22    let mut custom_update_schedule = Schedule::new(SingleThreadedUpdate);
23    custom_update_schedule.set_executor_kind(ExecutorKind::SingleThreaded);
24
25    // Adding the schedule to the app does not automatically run the schedule. This merely registers the schedule so
26    // that systems can look it up using the `Schedules` resource.
27    app.add_schedule(custom_update_schedule);
28
29    // Bevy `App`s have a `main_schedule_label` field that configures which schedule is run by the App's `runner`.
30    // By default, this is `Main`. The `Main` schedule is responsible for running Bevy's main schedules such as
31    // `Update`, `Startup` or `Last`.
32    //
33    // We can configure the `Main` schedule to run our custom update schedule relative to the existing ones by modifying
34    // the `MainScheduleOrder` resource.
35    //
36    // Note that we modify `MainScheduleOrder` directly in `main` and not in a startup system. The reason for this is
37    // that the `MainScheduleOrder` cannot be modified from systems that are run as part of the `Main` schedule.
38    let mut main_schedule_order = app.world_mut().resource_mut::<MainScheduleOrder>();
39    main_schedule_order.insert_after(Update, SingleThreadedUpdate);
40
41    // Adding a custom startup schedule works similarly, but needs to use `insert_startup_after`
42    // instead of `insert_after`.
43    app.add_schedule(Schedule::new(CustomStartup));
44
45    let mut main_schedule_order = app.world_mut().resource_mut::<MainScheduleOrder>();
46    main_schedule_order.insert_startup_after(PreStartup, CustomStartup);
47
48    app.add_systems(SingleThreadedUpdate, single_threaded_update_system)
49        .add_systems(CustomStartup, custom_startup_system)
50        .add_systems(PreStartup, pre_startup_system)
51        .add_systems(Startup, startup_system)
52        .add_systems(First, first_system)
53        .add_systems(Update, update_system)
54        .add_systems(Last, last_system)
55        .run();
56}
More examples
Hide additional examples
examples/stress_tests/many_components.rs (line 166)
79fn stress_test(num_entities: u32, num_components: u32, num_systems: u32) {
80    let mut rng = ChaCha8Rng::seed_from_u64(42);
81    let mut app = App::default();
82    let world = app.world_mut();
83
84    // register a bunch of components
85    let component_ids: Vec<ComponentId> = (1..=num_components)
86        .map(|i| {
87            world.register_component_with_descriptor(
88                // SAFETY:
89                // * We don't implement a drop function
90                // * u8 is Sync and Send
91                unsafe {
92                    ComponentDescriptor::new_with_layout(
93                        format!("Component{}", i).to_string(),
94                        StorageType::Table,
95                        Layout::new::<u8>(),
96                        None,
97                        true, // is mutable
98                        ComponentCloneBehavior::Default,
99                    )
100                },
101            )
102        })
103        .collect();
104
105    // fill the schedule with systems
106    let mut schedule = Schedule::new(Update);
107    for _ in 1..=num_systems {
108        let num_access_components = rng.gen_range(1..10);
109        let access_components: Vec<ComponentId> = component_ids
110            .choose_multiple(&mut rng, num_access_components)
111            .copied()
112            .collect();
113        let system = (QueryParamBuilder::new(|builder| {
114            for &access_component in &access_components {
115                if rand::random::<bool>() {
116                    builder.mut_id(access_component);
117                } else {
118                    builder.ref_id(access_component);
119                }
120            }
121        }),)
122            .build_state(world)
123            .build_any_system(base_system);
124        schedule.add_systems((move || access_components.clone()).pipe(system));
125    }
126
127    // spawn a bunch of entities
128    for _ in 1..=num_entities {
129        let num_components = rng.gen_range(1..10);
130        let components: Vec<ComponentId> = component_ids
131            .choose_multiple(&mut rng, num_components)
132            .copied()
133            .collect();
134
135        let mut entity = world.spawn_empty();
136        // We use `ManuallyDrop` here as we need to avoid dropping the u8's when `values` is dropped
137        // since ownership of the values is passed to the world in `insert_by_ids`.
138        // But we do want to deallocate the memory when values is dropped.
139        let mut values: Vec<ManuallyDrop<u8>> = components
140            .iter()
141            .map(|_id| ManuallyDrop::new(rng.gen_range(0..255)))
142            .collect();
143        let ptrs: Vec<OwningPtr> = values
144            .iter_mut()
145            .map(|value| {
146                // SAFETY:
147                // * We don't read/write `values` binding after this and values are `ManuallyDrop`,
148                // so we have the right to drop/move the values
149                unsafe { PtrMut::from(value).promote() }
150            })
151            .collect();
152        // SAFETY:
153        // * component_id's are from the same world
154        // * `values` was initialized above, so references are valid
155        unsafe {
156            entity.insert_by_ids(&components, ptrs.into_iter());
157        }
158    }
159
160    println!(
161        "Number of Archetype-Components: {}",
162        world.archetypes().archetype_components_len()
163    );
164
165    // overwrite Update schedule in the app
166    app.add_schedule(schedule);
167    app.add_plugins(MinimalPlugins)
168        .add_plugins(DiagnosticsPlugin)
169        .add_plugins(LogPlugin::default())
170        .add_plugins(FrameTimeDiagnosticsPlugin::default())
171        .add_plugins(LogDiagnosticsPlugin::filtered(vec![DiagnosticPath::new(
172            "fps",
173        )]));
174    app.run();
175}
Source

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

Initializes an empty schedule under the provided label, if it does not exist.

See add_schedule to insert an existing schedule.

Examples found in repository?
examples/games/stepping.rs (line 43)
34    fn build(&self, app: &mut App) {
35        app.add_systems(Startup, build_stepping_hint);
36        if cfg!(not(feature = "bevy_debug_stepping")) {
37            return;
38        }
39
40        // create and insert our debug schedule into the main schedule order.
41        // We need an independent schedule so we have access to all other
42        // schedules through the `Stepping` resource
43        app.init_schedule(DebugSchedule);
44        let mut order = app.world_mut().resource_mut::<MainScheduleOrder>();
45        order.insert_after(Update, DebugSchedule);
46
47        // create our stepping resource
48        let mut stepping = Stepping::new();
49        for label in &self.schedule_labels {
50            stepping.add_schedule(*label);
51        }
52        app.insert_resource(stepping);
53
54        // add our startup & stepping systems
55        app.insert_resource(State {
56            ui_top: self.top,
57            ui_left: self.left,
58            systems: Vec::new(),
59        })
60        .add_systems(
61            DebugSchedule,
62            (
63                build_ui.run_if(not(initialized)),
64                handle_input,
65                update_ui.run_if(initialized),
66            )
67                .chain(),
68        );
69    }
Source

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

Returns a reference to the Schedule with the provided label if it exists.

Source

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

Returns a mutable reference to the Schedule with the provided label if it exists.

Source

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

Runs function f with the Schedule associated with label.

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

Examples found in repository?
examples/ecs/nondeterministic_system_order.rs (lines 25-30)
20fn main() {
21    App::new()
22        // We can modify the reporting strategy for system execution order ambiguities on a per-schedule basis.
23        // You must do this for each schedule you want to inspect; child schedules executed within an inspected
24        // schedule do not inherit this modification.
25        .edit_schedule(Update, |schedule| {
26            schedule.set_build_settings(ScheduleBuildSettings {
27                ambiguity_detection: LogLevel::Warn,
28                ..default()
29            });
30        })
31        .init_resource::<A>()
32        .init_resource::<B>()
33        .add_systems(
34            Update,
35            (
36                // This pair of systems has an ambiguous order,
37                // as their data access conflicts, and there's no order between them.
38                reads_a,
39                writes_a,
40                // This pair of systems has conflicting data access,
41                // but it's resolved with an explicit ordering:
42                // the .after relationship here means that we will always double after adding.
43                adds_one_to_b,
44                doubles_b.after(adds_one_to_b),
45                // This system isn't ambiguous with adds_one_to_b,
46                // due to the transitive ordering created by our constraints:
47                // if A is before B is before C, then A must be before C as well.
48                reads_b.after(doubles_b),
49                // This system will conflict with all of our writing systems
50                // but we've silenced its ambiguity with adds_one_to_b.
51                // This should only be done in the case of clear false positives:
52                // leave a comment in your code justifying the decision!
53                reads_a_and_b.ambiguous_with(adds_one_to_b),
54            ),
55        )
56        // Be mindful, internal ambiguities are reported too!
57        // If there are any ambiguities due solely to DefaultPlugins,
58        // or between DefaultPlugins and any of your third party plugins,
59        // please file a bug with the repo responsible!
60        // Only *you* can prevent nondeterministic bugs due to greedy parallelism.
61        .add_plugins(DefaultPlugins)
62        .run();
63}
Source

pub fn configure_schedules( &mut self, schedule_build_settings: ScheduleBuildSettings, ) -> &mut App

Applies the provided ScheduleBuildSettings to all schedules.

Source

pub fn allow_ambiguous_component<T>(&mut self) -> &mut App
where T: Component,

When doing ambiguity checking this ignores systems that are ambiguous on Component T.

This settings only applies to the main world. To apply this to other worlds call the corresponding method on World

§Example

#[derive(Component)]
struct A;

// these systems are ambiguous on A
fn system_1(_: Query<&mut A>) {}
fn system_2(_: Query<&A>) {}

let mut app = App::new();
app.configure_schedules(ScheduleBuildSettings {
  ambiguity_detection: LogLevel::Error,
  ..default()
});

app.add_systems(Update, ( system_1, system_2 ));
app.allow_ambiguous_component::<A>();

// running the app does not error.
app.update();
Source

pub fn allow_ambiguous_resource<T>(&mut self) -> &mut App
where T: Resource,

When doing ambiguity checking this ignores systems that are ambiguous on Resource T.

This settings only applies to the main world. To apply this to other worlds call the corresponding method on World

§Example

#[derive(Resource)]
struct R;

// these systems are ambiguous on R
fn system_1(_: ResMut<R>) {}
fn system_2(_: Res<R>) {}

let mut app = App::new();
app.configure_schedules(ScheduleBuildSettings {
  ambiguity_detection: LogLevel::Error,
  ..default()
});
app.insert_resource(R);

app.add_systems(Update, ( system_1, system_2 ));
app.allow_ambiguous_resource::<R>();

// running the app does not error.
app.update();
Source

pub fn ignore_ambiguity<M1, M2, S1, S2>( &mut self, schedule: impl ScheduleLabel, a: S1, b: S2, ) -> &mut App
where S1: IntoSystemSet<M1>, S2: IntoSystemSet<M2>,

Suppress warnings and errors that would result from systems in these sets having ambiguities (conflicting access but indeterminate order) with systems in set.

When possible, do this directly in the .add_systems(Update, a.ambiguous_with(b)) call. However, sometimes two independent plugins A and B are reported as ambiguous, which you can only suppress as the consumer of both.

Source

pub fn should_exit(&self) -> Option<AppExit>

Attempts to determine if an AppExit was raised since the last update.

Will attempt to return the first Error it encounters. This should be called after every update() otherwise you risk dropping possible AppExit events.

Examples found in repository?
examples/app/custom_loop.rs (line 24)
10fn my_runner(mut app: App) -> AppExit {
11    // Finalize plugin building, including running any necessary clean-up.
12    // This is normally completed by the default runner.
13    app.finish();
14    app.cleanup();
15
16    println!("Type stuff into the console");
17    for line in io::stdin().lines() {
18        {
19            let mut input = app.world_mut().resource_mut::<Input>();
20            input.0 = line.unwrap();
21        }
22        app.update();
23
24        if let Some(exit) = app.should_exit() {
25            return exit;
26        }
27    }
28
29    AppExit::Success
30}
Source

pub fn add_observer<E, B, M>( &mut self, observer: impl IntoObserverSystem<E, B, M>, ) -> &mut App
where E: Event, B: Bundle,

Spawns an Observer entity, which will watch for and respond to the given event.

§Examples
// An observer system can be any system where the first parameter is a trigger
app.add_observer(|trigger: Trigger<Party>, friends: Query<Entity, With<Friend>>, mut commands: Commands| {
    if trigger.event().friends_allowed {
        for friend in friends.iter() {
            commands.trigger_targets(Invite, friend);
        }
    }
});
Examples found in repository?
examples/3d/edit_material_on_gltf.rs (line 20)
16fn main() {
17    App::new()
18        .add_plugins(DefaultPlugins.build().disable::<AudioPlugin>())
19        .add_systems(Startup, setup_scene)
20        .add_observer(change_material)
21        .run();
22}
More examples
Hide additional examples
examples/animation/animation_events.rs (line 15)
9fn main() {
10    App::new()
11        .add_plugins(DefaultPlugins)
12        .add_event::<MessageEvent>()
13        .add_systems(Startup, setup)
14        .add_systems(Update, animate_text_opacity)
15        .add_observer(edit_message)
16        .run();
17}
examples/ecs/entity_disabling.rs (line 26)
23fn main() {
24    App::new()
25        .add_plugins((DefaultPlugins, MeshPickingPlugin))
26        .add_observer(disable_entities_on_click)
27        .add_systems(
28            Update,
29            (list_all_named_entities, reenable_entities_on_space),
30        )
31        .add_systems(Startup, (setup_scene, display_instructions))
32        .run();
33}
examples/ecs/removal_detection.rs (line 20)
13fn main() {
14    App::new()
15        .add_plugins(DefaultPlugins)
16        .add_systems(Startup, setup)
17        // This system will remove a component after two seconds.
18        .add_systems(Update, remove_component)
19        // This observer will react to the removal of the component.
20        .add_observer(react_on_removal)
21        .run();
22}
examples/ecs/observer_propagation.rs (line 17)
8fn main() {
9    App::new()
10        .add_plugins((MinimalPlugins, LogPlugin::default()))
11        .add_systems(Startup, setup)
12        .add_systems(
13            Update,
14            attack_armor.run_if(on_timer(Duration::from_millis(200))),
15        )
16        // Add a global observer that will emit a line whenever an attack hits an entity.
17        .add_observer(attack_hits)
18        .run();
19}
examples/animation/animated_mesh_events.rs (line 27)
14fn main() {
15    App::new()
16        .insert_resource(AmbientLight {
17            color: Color::WHITE,
18            brightness: 2000.,
19            ..default()
20        })
21        .add_plugins(DefaultPlugins)
22        .init_resource::<ParticleAssets>()
23        .init_resource::<FoxFeetTargets>()
24        .add_systems(Startup, setup)
25        .add_systems(Update, setup_scene_once_loaded)
26        .add_systems(Update, simulate_particles)
27        .add_observer(observe_on_step)
28        .run();
29}
Additional examples can be found in:

Trait Implementations§

Source§

impl AddAudioSource for App

Source§

fn add_audio_source<T>(&mut self) -> &mut App
where T: Decodable + Asset, f32: FromSample<<T as Decodable>::DecoderItem>,

Registers an audio source. The type must implement Decodable, so that it can be converted to a rodio::Source type, and Asset, so that it can be registered as an asset. To use this method on App, the audio and asset plugins must be added first.
Source§

impl AddRenderCommand for App

Source§

fn add_render_command<P, C>(&mut self) -> &mut App
where P: PhaseItem, C: RenderCommand<P> + Send + Sync + 'static, <C as RenderCommand<P>>::Param: ReadOnlySystemParam,

Adds the RenderCommand for the specified render phase to the app.
Source§

impl AppExtStates for App

Source§

fn init_state<S>(&mut self) -> &mut App
where S: FreelyMutableState + FromWorld,

Initializes a State with standard starting values. Read more
Source§

fn insert_state<S>(&mut self, state: S) -> &mut App
where S: FreelyMutableState,

Inserts a specific State to the current App and overrides any State previously added of the same type. Read more
Source§

fn add_computed_state<S>(&mut self) -> &mut App
where S: ComputedStates,

Sets up a type implementing ComputedStates. Read more
Source§

fn add_sub_state<S>(&mut self) -> &mut App
where S: SubStates,

Sets up a type implementing SubStates. Read more
Source§

fn enable_state_scoped_entities<S>(&mut self) -> &mut App
where S: States,

Enable state-scoped entity clearing for state S. Read more
Source§

fn register_type_state<S>(&mut self) -> &mut App
where S: States + FromReflect + GetTypeRegistration + Typed,

Registers the state type T using App::register_type, and adds ReflectState type data to T in the type registry. Read more
Source§

fn register_type_mutable_state<S>(&mut self) -> &mut App
where S: FreelyMutableState + FromReflect + GetTypeRegistration + Typed,

Registers the state type T using App::register_type, and adds crate::reflect::ReflectState and crate::reflect::ReflectFreelyMutableState type data to T in the type registry. Read more
Source§

impl AppGizmoBuilder for App

Source§

fn init_gizmo_group<Config>(&mut self) -> &mut App
where Config: GizmoConfigGroup,

Registers GizmoConfigGroup in the app enabling the use of Gizmos<Config>. Read more
Source§

fn insert_gizmo_config<Config>( &mut self, group: Config, config: GizmoConfig, ) -> &mut App
where Config: GizmoConfigGroup,

Insert a GizmoConfig into a specific GizmoConfigGroup. Read more
Source§

impl AssetApp for App

Source§

fn register_asset_loader<L>(&mut self, loader: L) -> &mut App
where L: AssetLoader,

Registers the given loader in the App’s AssetServer.
Source§

fn register_asset_processor<P>(&mut self, processor: P) -> &mut App
where P: Process,

Registers the given processor in the App’s AssetProcessor.
Source§

fn register_asset_source( &mut self, id: impl Into<AssetSourceId<'static>>, source: AssetSourceBuilder, ) -> &mut App

Registers the given AssetSourceBuilder with the given id. Read more
Source§

fn set_default_asset_processor<P>(&mut self, extension: &str) -> &mut App
where P: Process,

Sets the default asset processor for the given extension.
Source§

fn init_asset_loader<L>(&mut self) -> &mut App
where L: AssetLoader + FromWorld,

Initializes the given loader in the App’s AssetServer.
Source§

fn init_asset<A>(&mut self) -> &mut App
where A: Asset,

Initializes the given Asset in the App by: Read more
Source§

fn register_asset_reflect<A>(&mut self) -> &mut App
where A: Asset + Reflect + FromReflect + GetTypeRegistration,

Registers the asset type T using [App::register], and adds ReflectAsset type data to T and ReflectHandle type data to Handle<T> in the type registry. Read more
Source§

fn preregister_asset_loader<L>(&mut self, extensions: &[&str]) -> &mut App
where L: AssetLoader,

Preregisters a loader for the given extensions, that will block asset loads until a real loader is registered.
Source§

impl Debug for App

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for App

Source§

fn default() -> App

Returns the “default value” for a type. Read more
Source§

impl RegisterDiagnostic for App

Source§

fn register_diagnostic(&mut self, diagnostic: Diagnostic) -> &mut App

Register a new Diagnostic with an App. Read more
Source§

impl RenderGraphApp for App

Source§

fn add_render_graph_node<T>( &mut self, sub_graph: impl RenderSubGraph, node_label: impl RenderLabel, ) -> &mut App
where T: Node + FromWorld,

Add a Node to the RenderGraph: Read more
Source§

fn add_render_graph_edge( &mut self, sub_graph: impl RenderSubGraph, output_node: impl RenderLabel, input_node: impl RenderLabel, ) -> &mut App

Add node edge to the specified graph
Source§

fn add_render_graph_edges<const N: usize>( &mut self, sub_graph: impl RenderSubGraph, edges: impl IntoRenderNodeArray<N>, ) -> &mut App

Automatically add the required node edges based on the given ordering
Source§

fn add_render_sub_graph(&mut self, sub_graph: impl RenderSubGraph) -> &mut App

Source§

impl StateScopedEventsAppExt for App

Source§

fn add_state_scoped_event<E>( &mut self, state: impl FreelyMutableState, ) -> &mut App
where E: Event,

Adds an Event that is automatically cleaned up when leaving the specified state. Read more

Auto Trait Implementations§

§

impl !Freeze for App

§

impl !RefUnwindSafe for App

§

impl !Send for App

§

impl !Sync for App

§

impl Unpin for App

§

impl !UnwindSafe for App

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

Source§

fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

Return the T ShaderType for self. When used in AsBindGroup derives, it is safe to assume that all images in self exist.
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> Conv for T

Source§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
Source§

impl<T> Downcast<T> for T

Source§

fn downcast(&self) -> &T

Source§

impl<T> Downcast for T
where T: Any,

Source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

fn as_any(&self) -> &(dyn Any + 'static)

Converts &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Converts &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> Downcast for T
where T: Any,

Source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> FmtForward for T

Source§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
Source§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
Source§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
Source§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
Source§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
Source§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
Source§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
Source§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
Source§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<S> FromSample<S> for S

Source§

fn from_sample_(s: S) -> S

Source§

impl<T> FromWorld for T
where T: Default,

Source§

fn from_world(_world: &mut World) -> T

Creates Self using default().

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<F, T> IntoSample<T> for F
where T: FromSample<F>,

Source§

fn into_sample(self) -> T

Source§

impl<T> NoneValue for T
where T: Default,

Source§

type NoneType = T

Source§

fn null_value() -> T

The none-equivalent value.
Source§

impl<T> Pipe for T
where T: ?Sized,

Source§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
Source§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
Source§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
Source§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
Source§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
Source§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
Source§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<R, P> ReadPrimitive<R> for P
where R: Read + ReadEndian<P>, P: Default,

Source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
Source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
Source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
Source§

impl<T> Tap for T

Source§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
Source§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
Source§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
Source§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
Source§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
Source§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
Source§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
Source§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
Source§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
Source§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
Source§

impl<T, U> ToSample<U> for T
where U: FromSample<T>,

Source§

fn to_sample_(self) -> U

Source§

impl<T> TryConv for T

Source§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> Upcast<T> for T

Source§

fn upcast(&self) -> Option<&T>

Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,