Struct PluginGroupBuilder 

pub struct PluginGroupBuilder { /* private fields */ }

Facilitates the creation and configuration of a PluginGroup.

Provides a build ordering to ensure that Plugins which produce/require a Resource are built before/after dependent/depending Plugins. Plugins inside the group can be disabled, enabled or reordered.

Implementations

impl PluginGroupBuilder

pub fn start<PG>() -> PluginGroupBuilder

where PG: PluginGroup,

Start a new builder for the PluginGroup.

Examples found in repository

examples/app/plugin_group.rs (line 31)

    fn build(self) -> PluginGroupBuilder {
        PluginGroupBuilder::start::<Self>()
            .add(PrintHelloPlugin)
            .add(PrintWorldPlugin)
    }

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

where T: Plugin,

Checks if the PluginGroupBuilder contains the given Plugin.

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

where T: Plugin,

Returns true if the PluginGroupBuilder contains the given Plugin and it’s enabled.

pub fn set<T>(self, plugin: T) -> PluginGroupBuilder

where T: Plugin,

Sets the value of the given Plugin, if it exists.

Panics

Panics if the Plugin does not exist.

Examples found in repository

examples/shader/compute_shader_game_of_life.rs (line 46)

fn main() {
    App::new()
        .insert_resource(ClearColor(Color::BLACK))
        .add_plugins((
            DefaultPlugins
                .set(WindowPlugin {
                    primary_window: Some(Window {
                        resolution: (SIZE * DISPLAY_FACTOR).into(),
                        // uncomment for unthrottled FPS
                        // present_mode: bevy::window::PresentMode::AutoNoVsync,
                        ..default()
                    }),
                    ..default()
                })
                .set(ImagePlugin::default_nearest()),
            GameOfLifeComputePlugin,
        ))
        .add_systems(Startup, setup)
        .add_systems(Update, switch_textures)
        .run();
}

examples/gltf/gltf_extension_mesh_2d.rs (lines 46-49)

fn main() {
    App::new()
        .insert_resource(GlobalAmbientLight {
            color: Color::WHITE,
            brightness: 2000.,
            ..default()
        })
        .add_plugins((
            DefaultPlugins
                .set(
                    GltfPlugin::default()
                        // Map a custom glTF attribute name to a `MeshVertexAttribute`.
                        // The glTF file used here has an attribute name with *two*
                        // underscores: __BARYCENTRIC
                        // One is stripped to do the comparison here.
                        .add_custom_vertex_attribute("_BARYCENTRIC", ATTRIBUTE_BARYCENTRIC),
                )
                .set(PbrPlugin {
                    gltf_enable_standard_materials: false,
                    ..Default::default()
                }),
            GltfToMesh2dPlugin,
        ))
        .add_systems(Startup, setup)
        .run();
}

examples/3d/clustered_decal_maps.rs (lines 145-151)

fn main() {
    App::new()
        .add_plugins((
            DefaultPlugins
                .set(WebAssetPlugin {
                    silence_startup_warning: true,
                })
                .set(WindowPlugin {
                    primary_window: Some(Window {
                        title: "Bevy Clustered Decal Maps Example".into(),
                        ..default()
                    }),
                    ..default()
                }),
            FeathersPlugins,
        ))
        .init_resource::<AppStatus>()
        .init_resource::<AppTextures>()
        .insert_resource(UiTheme(create_dark_theme()))
        .add_systems(Startup, setup)
        .add_systems(Update, draw_gizmos)
        .add_systems(Update, spawn_decal)
        .add_systems(Update, animate_decals)
        .add_observer(handle_emission_type_change)
        .add_observer(radio_self_update)
        .insert_resource(SeededRng(ChaCha8Rng::seed_from_u64(19878367467712)))
        .run();
}

examples/3d/occlusion_culling.rs (lines 187-190)

fn main() {
    let render_debug_flags = RenderDebugFlags::ALLOW_COPIES_FROM_INDIRECT_PARAMETERS;

    App::new()
        .add_plugins((
            DefaultPlugins
                .set(WindowPlugin {
                    primary_window: Some(Window {
                        title: "Bevy Occlusion Culling Example".into(),
                        ..default()
                    }),
                    ..default()
                })
                .set(RenderPlugin {
                    debug_flags: render_debug_flags,
                    ..default()
                })
                .set(PbrPlugin {
                    debug_flags: render_debug_flags,
                    ..default()
                }),
            FeathersPlugins,
        ))
        .add_plugins(ReadbackIndirectParametersPlugin)
        .insert_resource(UiTheme(theme::basic_example_theme(Color::WHITE)))
        .init_resource::<AppStatus>()
        .add_systems(Startup, setup)
        .add_systems(Update, spin_small_cubes)
        .add_systems(Update, spin_large_cube)
        .add_systems(Update, update_status_text)
        .add_observer(handle_selection_change)
        .add_observer(radio_self_update)
        .run();
}

examples/app/externally_driven_headless_renderer.rs (line 58)

    fn new() -> Self {
        let render_plugin = RenderPlugin {
            // Make sure all shaders are loaded for the first frame
            synchronous_pipeline_compilation: true,
            ..default()
        };
        // We don't have any windows, but the WindowPlugin is still needed
        // because a lot of bevy expects it to be there. Just configure it
        // to not have any windows and not exit automatically.
        let window_plugin = WindowPlugin {
            primary_window: None,
            exit_condition: ExitCondition::DontExit,
            ..default()
        };

        let mut app = App::new();
        app.add_plugins(
            DefaultPlugins
                .set(window_plugin)
                .set(render_plugin)
                // Disable winit because we want to own the update loop ourselves.
                .disable::<WinitPlugin>(),
        )
        .add_systems(Startup, spawn_test_scene)
        .add_systems(Update, update_camera);

        // We yeet the schedule runner and never call app.run(),
        // so we have to finish and clean up ourselves
        app.finish();
        app.cleanup();

        // We grab the sub apps cus we dont want the runner, as we'll
        // be pumping the update loop ourselves manually.
        Self(std::mem::take(app.sub_apps_mut()))
    }

examples/stress_tests/many_morph_targets.rs (lines 160-167)

fn main() {
    // `from_env` panics on the web
    #[cfg(not(target_arch = "wasm32"))]
    let args: Args = argh::from_env();
    #[cfg(target_arch = "wasm32")]
    let args = Args::from_args(&[], &[]).unwrap();

    App::new()
        .add_plugins((
            DefaultPlugins
                .set(WindowPlugin {
                    primary_window: Some(Window {
                        title: "Many Morph Targets".to_string(),
                        present_mode: PresentMode::AutoNoVsync,
                        resolution: WindowResolution::new(1920, 1080)
                            .with_scale_factor_override(1.0),
                        ..default()
                    }),
                    ..default()
                })
                .set(GltfPlugin {
                    mesh_compression: if args.mesh_compression {
                        MeshCompressionArgs::regular()
                    } else {
                        MeshCompressionArgs::none()
                    },
                    ..default()
                }),
            FrameTimeDiagnosticsPlugin::default(),
            LogDiagnosticsPlugin::default(),
        ))
        .insert_resource(WinitSettings::continuous())
        .insert_resource(GlobalAmbientLight {
            brightness: 1000.0,
            ..default()
        })
        .insert_resource(MorphAssets::default())
        .insert_resource(Rng(ChaCha8Rng::seed_from_u64(856673)))
        .insert_resource(State::new(&args))
        .insert_resource(args)
        .add_systems(Startup, setup)
        .add_systems(Update, update)
        .run();
}

Additional examples can be found in:

• examples/app/headless_renderer.rs
• examples/stress_tests/many_foxes.rs
• tests/ecs/ambiguity_detection.rs

pub fn try_set<T>( self, plugin: T, ) -> Result<PluginGroupBuilder, (PluginGroupBuilder, T)>

where T: Plugin,

Tries to set the value of the given Plugin, if it exists.

If the given plugin doesn’t exist returns self and the passed in Plugin.

pub fn add<T>(self, plugin: T) -> PluginGroupBuilder

where T: Plugin,

Adds the plugin Plugin at the end of this PluginGroupBuilder. If the plugin was already in the group, it is removed from its previous place.

Examples found in repository

examples/app/plugin_group.rs (line 32)

    fn build(self) -> PluginGroupBuilder {
        PluginGroupBuilder::start::<Self>()
            .add(PrintHelloPlugin)
            .add(PrintWorldPlugin)
    }

pub fn try_add<T>( self, plugin: T, ) -> Result<PluginGroupBuilder, (PluginGroupBuilder, T)>

where T: Plugin,

Attempts to add the plugin Plugin at the end of this PluginGroupBuilder.

If the plugin was already in the group the addition fails.

pub fn add_group(self, group: impl PluginGroup) -> PluginGroupBuilder

Adds a PluginGroup at the end of this PluginGroupBuilder. If the plugin was already in the group, it is removed from its previous place.

pub fn add_before<Target>(self, plugin: impl Plugin) -> PluginGroupBuilder

where Target: Plugin,

Adds a Plugin in this PluginGroupBuilder before the plugin of type Target.

If the plugin was already the group, it is removed from its previous place.

Panics

Panics if Target is not already in this PluginGroupBuilder.

pub fn try_add_before<Target, Insert>( self, plugin: Insert, ) -> Result<PluginGroupBuilder, (PluginGroupBuilder, Insert)>

where Target: Plugin, Insert: Plugin,

Adds a Plugin in this PluginGroupBuilder before the plugin of type Target.

If the plugin was already in the group the add fails. If there isn’t a plugin of type Target in the group the plugin we’re trying to insert is returned.

pub fn try_add_before_overwrite<Target, Insert>( self, plugin: Insert, ) -> Result<PluginGroupBuilder, (PluginGroupBuilder, Insert)>

where Target: Plugin, Insert: Plugin,

Adds a Plugin in this PluginGroupBuilder before the plugin of type Target.

If the plugin was already in the group, it is removed from its previous places. If there isn’t a plugin of type Target in the group the plugin we’re trying to insert is returned.

pub fn add_after<Target>(self, plugin: impl Plugin) -> PluginGroupBuilder

where Target: Plugin,

Adds a Plugin in this PluginGroupBuilder after the plugin of type Target.

If the plugin was already the group, it is removed from its previous place.

Panics

Panics if Target is not already in this PluginGroupBuilder.

pub fn try_add_after<Target, Insert>( self, plugin: Insert, ) -> Result<PluginGroupBuilder, (PluginGroupBuilder, Insert)>

where Target: Plugin, Insert: Plugin,

Adds a Plugin in this PluginGroupBuilder after the plugin of type Target.

If the plugin was already in the group the add fails. If there isn’t a plugin of type Target in the group the plugin we’re trying to insert is returned.

pub fn try_add_after_overwrite<Target, Insert>( self, plugin: Insert, ) -> Result<PluginGroupBuilder, (PluginGroupBuilder, Insert)>

where Target: Plugin, Insert: Plugin,

Adds a Plugin in this PluginGroupBuilder after the plugin of type Target.

If the plugin was already in the group, it is removed from its previous places. If there isn’t a plugin of type Target in the group the plugin we’re trying to insert is returned.

pub fn enable<T>(self) -> PluginGroupBuilder

where T: Plugin,

Enables a Plugin.

Plugins within a PluginGroup are enabled by default. This function is used to opt back in to a Plugin after disabling it. If there are no plugins of type T in this group, it will panic.

pub fn disable<T>(self) -> PluginGroupBuilder

where T: Plugin,

Disables a Plugin, preventing it from being added to the App with the rest of the PluginGroup. The disabled Plugin keeps its place in the PluginGroup, so it can still be used for ordering with add_before or add_after, or it can be re-enabled. If there are no plugins of type T in this group, it will panic.

Examples found in repository

examples/2d/mesh2d_repeated_texture.rs (line 20)

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.build().disable::<AudioPlugin>())
        .add_systems(Startup, setup)
        .run();
}

examples/app/without_winit.rs (line 7)

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.build().disable::<WinitPlugin>())
        .add_systems(Update, setup_system)
        .run();
}

examples/gltf/edit_material_on_gltf.rs (line 10)

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.build().disable::<AudioPlugin>())
        .add_systems(Startup, setup_scene)
        .add_observer(change_material)
        .run();
}

examples/app/headless.rs (line 42)

fn main() {
    if cfg!(feature = "bevy_window") {
        println!("This example is running with the bevy_window feature enabled and will not run headless.");
        println!("Disable the default features and rerun the example to run headless.");
        println!("To do so, run:");
        println!();
        println!("    cargo run --example headless --no-default-features --features bevy_log");
        return;
    }

    // This app runs once
    App::new()
        .add_plugins(DefaultPlugins.set(ScheduleRunnerPlugin::run_once()))
        .add_systems(Update, hello_world_system)
        .run();

    // This app loops forever at 60 fps
    App::new()
        .add_plugins(
            DefaultPlugins
                .set(ScheduleRunnerPlugin::run_loop(Duration::from_secs_f64(
                    1.0 / 60.0,
                )))
                // The log and ctrl+c plugin can only be registered once globally,
                // which means we need to disable it here, because it was already registered with the
                // app that runs once.
                .disable::<LogPlugin>(),
        )
        .add_systems(Update, counter)
        .run();
}

examples/app/externally_driven_headless_renderer.rs (line 60)

    fn new() -> Self {
        let render_plugin = RenderPlugin {
            // Make sure all shaders are loaded for the first frame
            synchronous_pipeline_compilation: true,
            ..default()
        };
        // We don't have any windows, but the WindowPlugin is still needed
        // because a lot of bevy expects it to be there. Just configure it
        // to not have any windows and not exit automatically.
        let window_plugin = WindowPlugin {
            primary_window: None,
            exit_condition: ExitCondition::DontExit,
            ..default()
        };

        let mut app = App::new();
        app.add_plugins(
            DefaultPlugins
                .set(window_plugin)
                .set(render_plugin)
                // Disable winit because we want to own the update loop ourselves.
                .disable::<WinitPlugin>(),
        )
        .add_systems(Startup, spawn_test_scene)
        .add_systems(Update, update_camera);

        // We yeet the schedule runner and never call app.run(),
        // so we have to finish and clean up ourselves
        app.finish();
        app.cleanup();

        // We grab the sub apps cus we dont want the runner, as we'll
        // be pumping the update loop ourselves manually.
        Self(std::mem::take(app.sub_apps_mut()))
    }

examples/app/headless_renderer.rs (line 98)

fn main() {
    let config = AppConfig {
        width: 1920,
        height: 1080,
        single_image: true,
    };

    // setup frame capture
    App::new()
        .insert_resource(SceneController::new(
            config.width,
            config.height,
            config.single_image,
        ))
        .insert_resource(ClearColor(Color::srgb_u8(0, 0, 0)))
        .add_plugins(
            DefaultPlugins
                .set(ImagePlugin::default_nearest())
                // Not strictly necessary, as the inclusion of ScheduleRunnerPlugin below
                // replaces the bevy_winit app runner and so a window is never created.
                .set(WindowPlugin {
                    primary_window: None,
                    // Don’t automatically exit due to having no windows.
                    // Instead, the code in `update()` will explicitly produce an `AppExit` event.
                    exit_condition: ExitCondition::DontExit,
                    ..default()
                })
                // WinitPlugin will panic in environments without a display server.
                .disable::<WinitPlugin>(),
        )
        .add_plugins(ImageCopyPlugin)
        // headless frame capture
        .add_plugins(CaptureFramePlugin)
        // ScheduleRunnerPlugin provides an alternative to the default bevy_winit app runner, which
        // manages the loop without creating a window.
        .add_plugins(ScheduleRunnerPlugin::run_loop(
            // Run 60 times per second.
            Duration::from_secs_f64(1.0 / 60.0),
        ))
        .init_resource::<SceneController>()
        .add_systems(Startup, setup)
        .run();
}

Additional examples can be found in:

• tests/ecs/ambiguity_detection.rs

pub fn finish(self, app: &mut App)

Consumes the PluginGroupBuilder and builds the contained Plugins in the order specified.

Panics

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

Trait Implementations

impl PluginGroup for PluginGroupBuilder

fn build(self) -> PluginGroupBuilder

Configures the Plugins that are to be added.

fn name() -> String

Configures a name for the PluginGroup which is primarily used for debugging.

fn set<T>(self, plugin: T) -> PluginGroupBuilder

where T: Plugin,

Sets the value of the given Plugin, if it exists