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, Default)]
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.

Examples found in repository

examples/app/externally_driven_headless_renderer.rs (line 101)

    fn update(&mut self) {
        self.0.update();
        // Wait for frame to finish rendering by wait polling the device
        self.0
            .main
            .world()
            .resource::<RenderDevice>()
            .wgpu_device()
            .poll(PollType::Wait {
                submission_index: None,
                timeout: None,
            })
            .unwrap();
    }

tests/ecs/ambiguity_detection.rs (line 93)

fn count_ambiguities(sub_app: &mut SubApp) -> AmbiguitiesCount {
    let schedule_labels = sub_app
        .world()
        .resource::<Schedules>()
        .iter()
        .map(|(_, schedule)| schedule.label())
        .collect::<Vec<_>>();
    let mut ambiguities = <HashMap<_, _>>::default();
    for label in schedule_labels {
        let ambiguities_in_schedule =
            sub_app
                .world_mut()
                .schedule_scope(label, |world, schedule| {
                    schedule.initialize(world).unwrap().unwrap();
                    schedule.graph().conflicting_systems().len()
                });
        ambiguities.insert(label, ambiguities_in_schedule);
    }
    AmbiguitiesCount(ambiguities)
}

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

Returns a mutable reference to the World.

Examples found in repository

examples/app/externally_driven_headless_renderer.rs (line 81)

    fn new_render_target(&mut self, width: u32, height: u32) -> RenderTarget {
        let mut target =
            Image::new_target_texture(width, height, TextureFormat::Rgba8UnormSrgb, None);
        target.asset_usage = RenderAssetUsages::RENDER_WORLD;
        self.0
            .main
            .world_mut()
            .resource_mut::<Assets<Image>>()
            .add(target)
            .into()
    }

    fn spawn_camera(&mut self, target: RenderTarget) -> Entity {
        self.0
            .main
            .world_mut()
            .spawn((Camera3d::default(), target, Transform::IDENTITY))
            .id()
    }

    // Run one world update and wait for rendering to finish.
    fn update(&mut self) {
        self.0.update();
        // Wait for frame to finish rendering by wait polling the device
        self.0
            .main
            .world()
            .resource::<RenderDevice>()
            .wgpu_device()
            .poll(PollType::Wait {
                submission_index: None,
                timeout: None,
            })
            .unwrap();
    }

    // Schedules a screenshot to be captured on the next update.
    fn screenshot(&mut self, target: RenderTarget, i: u32) {
        self.0
            .main
            .world_mut()
            .spawn(Screenshot::image(target.as_image().unwrap().clone()))
            .observe(save_to_disk(format!("test_images/screenshot{i}.png")));
    }

examples/shader_advanced/compute_mesh.rs (line 67)

    fn finish(&self, app: &mut App) {
        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
            return;
        };
        render_app
            .world_mut()
            .resource_mut::<MeshAllocatorSettings>()
            // This allows using the mesh allocator slabs as
            // storage buffers directly in the compute shader.
            // Which means that we can write from our compute
            // shader directly to the allocated mesh slabs.
            .extra_buffer_usages = BufferUsages::STORAGE;
    }

tests/ecs/ambiguity_detection.rs (line 71)

fn configure_ambiguity_detection(sub_app: &mut SubApp) {
    let mut schedules = sub_app.world_mut().resource_mut::<Schedules>();
    for (_, schedule) in schedules.iter_mut() {
        schedule.set_build_settings(ScheduleBuildSettings {
            // NOTE: you can change this to `LogLevel::Ignore` to easily see the current number of ambiguities.
            ambiguity_detection: LogLevel::Warn,
            // With auto-inserted apply_deferred stages, these can cause two ambiguous systems to
            // become accidentally ordered by one of the apply_deferred stages. Disabling requires
            // us to meet a higher bar. We don't just want no ambiguities - we also don't want
            // changes to systems or the auto-insert code from "creating" new ambiguities (by
            // reordering the graph). However, the cost is that the graph is no longer runnable,
            // since Bevy crates often rely on auto-insert apply_deferred to not panic (e.g.,
            // because a resource wasn't inserted).
            auto_insert_apply_deferred: false,
            use_shortnames: false,
            ..default()
        });
    }
}

/// Returns the number of conflicting systems per schedule.
fn count_ambiguities(sub_app: &mut SubApp) -> AmbiguitiesCount {
    let schedule_labels = sub_app
        .world()
        .resource::<Schedules>()
        .iter()
        .map(|(_, schedule)| schedule.label())
        .collect::<Vec<_>>();
    let mut ambiguities = <HashMap<_, _>>::default();
    for label in schedule_labels {
        let ambiguities_in_schedule =
            sub_app
                .world_mut()
                .schedule_scope(label, |world, schedule| {
                    schedule.initialize(world).unwrap().unwrap();
                    schedule.graph().conflicting_systems().len()
                });
        ambiguities.insert(label, ambiguities_in_schedule);
    }
    AmbiguitiesCount(ambiguities)
}

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.

Examples found in repository

examples/ecs/extraction.rs (line 67)

fn main() {
    let mut app = App::new();

    // Main World
    app.insert_resource(WorldName("Main World".into()))
        .add_plugins((
            DefaultPlugins,
            // Plugin for automatically extracting A.
            ExtractComponentPlugin::<A>::default(),
        ))
        .add_message::<ExtractMessage>()
        .add_systems(Startup, setup)
        .add_systems(Update, (set_time, trigger_extraction, display_state));

    let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
        return;
    };

    // Render World
    render_app
        .insert_resource(WorldName("Render World".into()))
        .add_systems(ExtractSchedule, extract_components)
        .add_systems(Render, display_state);

    app.run();
}

examples/app/headless_renderer.rs (line 213)

    fn build(&self, app: &mut App) {
        let (s, r) = crossbeam_channel::unbounded();

        let render_app = app
            .insert_resource(MainWorldReceiver(r))
            .sub_app_mut(RenderApp);

        render_app
            .insert_resource(RenderWorldSender(s))
            // Make ImageCopiers accessible in RenderWorld system and plugin
            .add_systems(ExtractSchedule, image_copy_extract)
            // Receives image data from buffer to channel
            // so we need to run it after the render graph is done
            .add_systems(
                Render,
                receive_image_from_buffer.after(RenderSystems::Render),
            )
            .add_systems(
                RenderGraph,
                image_copy_driver.after(RenderGraphSystems::Submit),
            );
    }

examples/3d/occlusion_culling.rs (line 227)

    fn build(&self, app: &mut App) {
        // Create the `SavedIndirectParameters` resource that we're going to use
        // to communicate between the thread that the GPU-to-CPU readback
        // callback runs on and the main application threads. This resource is
        // atomically reference counted. We store one reference to the
        // `SavedIndirectParameters` in the main app and another reference in
        // the render app.
        let saved_indirect_parameters = SavedIndirectParameters::new();
        app.insert_resource(saved_indirect_parameters.clone());

        // Fetch the render app.
        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
            return;
        };

        render_app
            // Insert another reference to the `SavedIndirectParameters`.
            .insert_resource(saved_indirect_parameters)
            // Setup the parameters in RenderStartup.
            .add_systems(RenderStartup, init_saved_indirect_parameters)
            .init_resource::<IndirectParametersStagingBuffers>()
            .add_systems(ExtractSchedule, readback_indirect_parameters)
            .add_systems(
                Render,
                create_indirect_parameters_staging_buffers
                    .in_set(RenderSystems::PrepareResourcesFlush),
            )
            .add_systems(
                Core3d,
                // Add the node that allows us to read the indirect parameters back
                // from the GPU to the CPU, which allows us to determine how many
                // meshes were culled.
                readback_indirect_parameters_node
                    // We read back the indirect parameters any time after
                    // `MainPass`. Readback doesn't particularly need to execute
                    // before PostProcess, but we order it that way anyway.
                    .after(Core3dSystems::MainPass)
                    .before(Core3dSystems::PostProcess),
            );
    }

examples/2d/mesh2d_manual.rs (line 338)

    fn build(&self, app: &mut App) {
        // Load our custom shader
        let mut shaders = app.world_mut().resource_mut::<Assets<Shader>>();
        // Here, we construct and add the shader asset manually. There are many ways to load this
        // shader, including `embedded_asset`/`load_embedded_asset`.
        let shader = shaders.add(Shader::from_wesl(COLORED_MESH2D_SHADER, file!()));

        app.add_plugins(SyncComponentPlugin::<ColoredMesh2d>::default());

        // Register our custom draw function, and add our render systems
        app.get_sub_app_mut(RenderApp)
            .unwrap()
            .init_resource::<DrawFunctions<TransparentColoredMesh2d>>()
            // Declare a render phase, `TransparentColoredMesh2d`, to go with
            // our pipeline.
            .init_resource::<ViewSortedRenderPhases<TransparentColoredMesh2d>>()
            // Declare the pipeline itself.
            .init_resource::<SpecializedRenderPipelines<ColoredMesh2dPipeline>>()
            // Declare the render-world resource that will hold the instances.
            .init_resource::<RenderColoredMesh2dInstances>()
            .insert_resource(ColoredMesh2dShader(shader))
            // Declare a new render command.
            .add_render_command::<TransparentColoredMesh2d, DrawTransparentColoredMesh2d>()
            .add_systems(
                RenderStartup,
                init_colored_mesh_2d_pipeline.after(init_mesh_2d_pipeline),
            )
            .add_systems(
                ExtractSchedule,
                (
                    extract_colored_mesh2d.after(extract_2d_meshes),
                    extract_colored_mesh2d_camera_phases,
                ),
            )
            .add_systems(
                Render,
                (
                    sort_phase_system::<TransparentColoredMesh2d>.in_set(RenderSystems::PhaseSort),
                    queue_colored_mesh2d.in_set(RenderSystems::QueueMeshes),
                    // Make sure to prepare the render phase.
                    batch_and_prepare_sorted_render_phase::<
                        TransparentColoredMesh2d,
                        ColoredMesh2dPipeline,
                    >
                        .in_set(RenderSystems::PrepareResources),
                ),
            )
            .add_systems(
                Core2d,
                // Add the draw command to draw the items in our custom phase.
                main_colored_transparent_pass_2d.in_set(Core2dSystems::MainPass),
            );
    }

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

where R: Resource + FromWorld,

See App::init_resource.

Examples found in repository

examples/shader_advanced/compute_mesh.rs (line 57)

    fn build(&self, app: &mut App) {
        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
            return;
        };

        render_app
            .init_resource::<ChunksToProcess>()
            .add_systems(RenderStartup, init_compute_pipeline)
            .add_systems(Render, prepare_chunks)
            .add_systems(RenderGraph, compute_mesh.before(camera_driver));
    }

examples/shader_advanced/custom_shader_instancing.rs (line 114)

    fn build(&self, app: &mut App) {
        app.add_plugins(ExtractComponentPlugin::<InstanceMaterialData>::default());
        app.sub_app_mut(RenderApp)
            .add_render_command::<Transparent3d, DrawCustom>()
            .init_resource::<SpecializedMeshPipelines<CustomPipeline>>()
            .add_systems(
                RenderStartup,
                init_custom_pipeline.after(MeshPipelineSystems),
            )
            .add_systems(
                Render,
                (
                    queue_custom.in_set(RenderSystems::QueueMeshes),
                    prepare_instance_buffers.in_set(RenderSystems::PrepareResources),
                ),
            );
    }

examples/shader_advanced/custom_phase_item.rs (line 174)

fn main() {
    let mut app = App::new();
    app.add_plugins(DefaultPlugins)
        .add_plugins(ExtractComponentPlugin::<CustomRenderedEntity>::default())
        .add_systems(Startup, setup);

    // We make sure to add these to the render app, not the main app.
    app.sub_app_mut(RenderApp)
        .init_resource::<CustomPhasePipeline>()
        .init_resource::<PendingCustomPhaseItemQueues>()
        .add_render_command::<Opaque3d, DrawCustomPhaseItemCommands>()
        .add_systems(
            Render,
            prepare_custom_phase_item_buffers.in_set(RenderSystems::Prepare),
        )
        .add_systems(Render, queue_custom_phase_item.in_set(RenderSystems::Queue));

    app.run();
}

examples/shader/compute_shader_game_of_life.rs (line 103)

    fn build(&self, app: &mut App) {
        // Extract the game of life image resource from the main world into the render world
        // for operation on by the compute shader and display on the sprite.
        app.add_plugins((
            ExtractResourcePlugin::<GameOfLifeImages>::default(),
            ExtractResourcePlugin::<GameOfLifeUniforms>::default(),
        ));
        let render_app = app.sub_app_mut(RenderApp);
        render_app
            .init_resource::<GameOfLifeState>()
            .add_systems(RenderStartup, init_game_of_life_pipeline)
            .add_systems(
                Render,
                prepare_bind_group.in_set(RenderSystems::PrepareBindGroups),
            )
            .add_systems(Render, update.in_set(RenderSystems::Prepare))
            .add_systems(RenderGraph, game_of_life.before(camera_driver));
    }

examples/shader_advanced/specialized_mesh_pipeline.rs (line 137)

    fn build(&self, app: &mut App) {
        app.add_plugins(ExtractComponentPlugin::<CustomRenderedEntity>::default());

        // We make sure to add these to the render app, not the main app.
        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
            return;
        };
        render_app
            // This is needed to tell bevy about your custom pipeline
            .init_resource::<SpecializedMeshPipelines<CustomMeshPipeline>>()
            .init_resource::<PendingCustomMeshQueues>()
            // We need to use a custom draw command so we need to register it
            .add_render_command::<Opaque3d, DrawSpecializedPipelineCommands>()
            .add_systems(
                RenderStartup,
                init_custom_mesh_pipeline.after(MeshPipelineSystems),
            )
            .add_systems(
                Render,
                queue_custom_mesh_pipeline.in_set(RenderSystems::Queue),
            );
    }

examples/shader_advanced/custom_render_phase.rs (line 146)

    fn build(&self, app: &mut App) {
        app.add_plugins((
            ExtractComponentPlugin::<DrawStencil>::default(),
            SortedRenderPhasePlugin::<Stencil3d, MeshPipeline>::new(RenderDebugFlags::default()),
        ));
        // We need to get the render app from the main app
        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
            return;
        };
        render_app
            .init_resource::<SpecializedMeshPipelines<StencilPipeline>>()
            .init_resource::<DrawFunctions<Stencil3d>>()
            .add_render_command::<Stencil3d, DrawMesh3dStencil>()
            .init_resource::<ViewSortedRenderPhases<Stencil3d>>()
            .init_resource::<PendingCustomMeshQueues>()
            .add_systems(
                RenderStartup,
                init_stencil_pipeline.after(MeshPipelineSystems),
            )
            .add_systems(ExtractSchedule, extract_camera_phases)
            .add_systems(
                Render,
                (
                    queue_custom_meshes.in_set(RenderSystems::QueueMeshes),
                    sort_phase_system::<Stencil3d>.in_set(RenderSystems::PhaseSort),
                    batch_and_prepare_sorted_render_phase::<Stencil3d, StencilPipeline>
                        .in_set(RenderSystems::PrepareResources),
                ),
            )
            .add_systems(
                Core3d,
                custom_draw_system
                    .after(main_opaque_pass_3d)
                    .in_set(Core3dSystems::MainPass),
            );
    }

Additional examples can be found in:

• tests/ecs/ambiguity_detection.rs
• examples/3d/occlusion_culling.rs
• examples/2d/mesh2d_manual.rs

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.

Examples found in repository

examples/shader_advanced/texture_binding_array.rs (line 51)

    fn build(&self, app: &mut App) {
        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
            return;
        };

        render_app.add_systems(RenderStartup, verify_required_features);
    }

examples/stress_tests/many_lights.rs (lines 158-161)

    fn build(&self, app: &mut App) {
        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
            return;
        };

        render_app.add_systems(
            Render,
            print_visible_light_count.in_set(RenderSystems::Prepare),
        );
    }

examples/app/render_recovery.rs (line 30)

fn main() {
    let mut app = App::new();
    app.add_plugins((
        DefaultPlugins,
        ExtractResourcePlugin::<RenderError>::default(),
    ))
    .add_systems(Startup, setup)
    .add_systems(Update, (update_camera, input))
    .init_resource::<RenderError>()
    .sub_app_mut(RenderApp)
    .add_systems(Render, cause_error);
    app.run();
}

examples/shader_advanced/compute_mesh.rs (line 58)

    fn build(&self, app: &mut App) {
        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
            return;
        };

        render_app
            .init_resource::<ChunksToProcess>()
            .add_systems(RenderStartup, init_compute_pipeline)
            .add_systems(Render, prepare_chunks)
            .add_systems(RenderGraph, compute_mesh.before(camera_driver));
    }

examples/shader_advanced/mesh_shader_intro.rs (line 119)

    fn build(&self, app: &mut App) {
        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
            return;
        };

        render_app
            .add_systems(RenderStartup, init_mesh_pipelines)
            .add_systems(
                Core3d,
                draw_mesh_shader_cubes
                    .after(main_opaque_pass_3d)
                    .in_set(Core3dSystems::MainPass),
            );
    }

examples/showcase/loading_screen.rs (line 293)

        fn build(&self, app: &mut App) {
            app.insert_resource(PipelinesReady::default());

            // In order to gain access to the pipelines status, we have to
            // go into the `RenderApp`, grab the resource from the main App
            // and then update the pipelines status from there.
            // Writing between these Apps can only be done through the
            // `ExtractSchedule`.
            app.sub_app_mut(RenderApp)
                .add_systems(ExtractSchedule, update_pipelines_ready);
        }

Additional examples can be found in:

• examples/shader/gpu_readback.rs
• examples/shader_advanced/custom_shader_instancing.rs
• examples/shader_advanced/custom_phase_item.rs
• examples/ecs/extraction.rs
• examples/shader_advanced/render_depth_to_texture.rs
• examples/app/headless_renderer.rs
• examples/shader/compute_shader_game_of_life.rs
• examples/shader_advanced/specialized_mesh_pipeline.rs
• examples/shader_advanced/manual_material.rs
• examples/shader_advanced/deferred_raymarch.rs
• examples/shader_advanced/custom_post_processing.rs
• examples/shader_advanced/custom_render_phase.rs
• examples/2d/dynamic_mip_generation.rs
• examples/3d/occlusion_culling.rs
• examples/2d/mesh2d_manual.rs

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,

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: CreateTypeData<T>,

Available on crate feature bevy_reflect only.

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,

Available on crate feature bevy_reflect only.

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>,

Available on crate feature bevy_reflect only.

See App::register_into_type_conversion.

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

As part of default initialization, we schedule a message_update_system in First. We expect all SubApp implementations to schedule First regularly.

impl GpuResourceAppExt for SubApp

fn init_gpu_resource<R>(&mut self) -> &mut SubApp

where R: Resource + FromWorld,

Causes the provided GPU resource to be re-initialized during RenderStartup.

impl RegisterDiagnostic for SubApp

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

Register a new Diagnostic with an App.

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.