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<In = (), Out = ()>>, 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 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_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,

Available on crate feature bevy_reflect only.

See App::register_type.

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

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

Available on crate feature bevy_reflect only.

See App::register_type_data.

pub fn register_function<F, Marker>(&mut self, function: F) -> &mut SubApp

where F: IntoFunction<'static, Marker> + 'static,

Available on crate feature reflect_functions only.

See App::register_function.

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

where F: IntoFunction<'static, Marker> + 'static,

Available on crate feature reflect_functions only.

See App::register_function_with_name.

Trait Implementations

impl AddRenderCommand for SubApp

fn add_render_command<P, C>(&mut self) -> &mut SubApp

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.

impl AppExtStates for SubApp

fn init_state<S>(&mut self) -> &mut SubApp

where S: FreelyMutableState + FromWorld,

Initializes a State with standard starting values.

fn insert_state<S>(&mut self, state: S) -> &mut SubApp

where S: FreelyMutableState,

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

fn add_computed_state<S>(&mut self) -> &mut SubApp

where S: ComputedStates,

Sets up a type implementing ComputedStates.

fn add_sub_state<S>(&mut self) -> &mut SubApp

where S: SubStates,

Sets up a type implementing SubStates.

fn register_type_state<S>(&mut self) -> &mut SubApp

where S: States + FromReflect + GetTypeRegistration + Typed,

Available on crate feature bevy_reflect only.

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

fn register_type_mutable_state<S>(&mut self) -> &mut SubApp

where S: FreelyMutableState + FromReflect + GetTypeRegistration + Typed,

Available on crate feature bevy_reflect only.

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.

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.

impl RegisterDiagnostic for SubApp

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

Register a new Diagnostic with an App.

impl RenderGraphExt for SubApp

fn add_render_graph_node<T>( &mut self, sub_graph: impl RenderSubGraph, node_label: impl RenderLabel, ) -> &mut SubApp

where T: Node + FromWorld,

Add a Node to the RenderGraph:

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

Add node edge to the specified graph

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

Automatically add the required node edges based on the given ordering

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

impl StateScopedMessagesAppExt for SubApp

fn clear_messages_on_exit<M>(&mut self, state: impl States) -> &mut SubApp

where M: Message,

Clears a Message when exiting the specified state.

fn clear_messages_on_enter<M>(&mut self, state: impl States) -> &mut SubApp

where M: Message,

Clears a Message when entering the specified state.