Struct SubApp 

pub struct SubApp {
    pub update_schedule: Option<Interned<dyn ScheduleLabel>>,
    /* private fields */
}

A secondary application with its own World. These can run independently of each other.

These are useful for situations where certain processes (e.g. a render thread) need to be kept separate from the main application.

Example

#[derive(Resource, Default)]
struct Val(pub i32);

#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, AppLabel)]
struct ExampleApp;

// Create an app with a certain resource.
let mut app = App::new();
app.insert_resource(Val(10));

// Create a sub-app with the same resource and a single schedule.
let mut sub_app = SubApp::new();
sub_app.update_schedule = Some(Main.intern());
sub_app.insert_resource(Val(100));

// Setup an extract function to copy the resource's value in the main world.
sub_app.set_extract(|main_world, sub_world| {
    sub_world.resource_mut::<Val>().0 = main_world.resource::<Val>().0;
});

// Schedule a system that will verify extraction is working.
sub_app.add_systems(Main, |counter: Res<Val>| {
    // The value will be copied during extraction, so we should see 10 instead of 100.
    assert_eq!(counter.0, 10);
});

// Add the sub-app to the main app.
app.insert_sub_app(ExampleApp, sub_app);

// Update the application once (using the default runner).
app.run();

Fields

update_schedule: Option<Interned<dyn ScheduleLabel>>

The schedule that will be run by update.

Implementations

impl SubApp

pub fn new() -> SubApp

Returns a default, empty SubApp.

pub fn world(&self) -> &World

Returns a reference to the World.

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

Returns a mutable reference to the World.

pub fn run_default_schedule(&mut self)

Runs the default schedule.

Does not clear internal trackers used for change detection.

pub fn update(&mut self)

Runs the default schedule and updates internal component trackers.

pub fn extract(&mut self, world: &mut World)

Extracts data from world into the app’s world using the registered extract method.

Note: There is no default extract method. Calling extract does nothing if set_extract has not been called.

pub fn set_extract<F>(&mut self, extract: F) -> &mut SubApp

where F: FnMut(&mut World, &mut World) + Send + 'static,

Sets the method that will be called by extract.

The first argument is the World to extract data from, the second argument is the app World.

pub fn take_extract( &mut self, ) -> Option<Box<dyn FnMut(&mut World, &mut World) + Send>>

Take the function that will be called by extract out of the app, if any was set, and replace it with None.

If you use Bevy, bevy_render will set a default extract function used to extract data from the main world into the render world as part of the Extract phase. In that case, you cannot replace it with your own function. Instead, take the Bevy default function with this, and install your own instead which calls the Bevy default.

let mut default_fn = app.take_extract();
app.set_extract(move |main, render| {
    // Do pre-extract custom logic
    // [...]

    // Call Bevy's default, which executes the Extract phase
    if let Some(f) = default_fn.as_mut() {
        f(main, render);
    }

    // Do post-extract custom logic
    // [...]
});

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

where R: Resource,

See App::insert_resource.

pub fn init_resource<R>(&mut self) -> &mut SubApp

where R: Resource + FromWorld,

See App::init_resource.

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

See App::add_systems.

pub fn remove_systems_in_set<M>( &mut self, schedule: impl ScheduleLabel, set: impl IntoSystemSet<M>, policy: ScheduleCleanupPolicy, ) -> Result<usize, ScheduleError>

See App::remove_systems_in_set

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,

See App::register_system.

pub fn register_tracked_system<I, O, M>( &mut self, system: impl IntoSystem<I, O, M> + 'static, ) -> SystemHandle<I, O>

where I: SystemInput + 'static, O: 'static,

See App::register_tracked_system.

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

See App::configure_sets.

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

See App::add_schedule.

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

See App::init_schedule.

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

See App::get_schedule.

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

See App::get_schedule_mut.

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

See App::edit_schedule.

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

See App::configure_schedules.

pub fn allow_ambiguous_component<T>(&mut self) -> &mut SubApp

where T: Component,

See App::allow_ambiguous_component.

pub fn allow_ambiguous_resource<T>(&mut self) -> &mut SubApp

where T: Resource,

See App::allow_ambiguous_resource.

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

where S1: IntoSystemSet<M1>, S2: IntoSystemSet<M2>,

See App::ignore_ambiguity.

pub fn add_observer<M>(&mut self, observer: impl IntoObserver<M>) -> &mut SubApp

See App::add_observer.

pub fn add_message<T>(&mut self) -> &mut SubApp

where T: Message,

See App::add_message.

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

See App::add_plugins.

pub fn is_plugin_added<T>(&self) -> bool

where T: Plugin,

See App::is_plugin_added.

pub fn get_added_plugins<T>(&self) -> Vec<&T>

where T: Plugin,

See App::get_added_plugins.

pub fn plugins_state(&mut self) -> PluginsState

Return the state of plugins.

pub fn finish(&mut self)

Runs Plugin::finish for each plugin.

pub fn cleanup(&mut self)

Runs Plugin::cleanup for each plugin.

pub fn register_type<T>(&mut self) -> &mut SubApp

where T: GetTypeRegistration,

See App::register_type.

pub fn register_type_data<T, D>(&mut self) -> &mut SubApp

where T: Reflect + TypePath, D: TypeData + FromType<T>,

See App::register_type_data.

pub fn register_type_conversion<T, U, F>(&mut self, function: F) -> &mut SubApp

where T: Reflect + TypePath, U: Reflect + TypePath, F: Fn(T) -> Result<U, T> + Clone + Send + Sync + 'static,

See App::register_type_conversion.

pub fn register_into_type_conversion<T, U>(&mut self) -> &mut SubApp

where T: Reflect + TypePath, U: Reflect + TypePath + From<T>,

See App::register_into_type_conversion.

Trait Implementations

impl Debug for SubApp

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

Formats the value using the given formatter.

impl Default for SubApp

fn default() -> SubApp

Returns the “default value” for a type.