Mirrors/bevy
2
0
Fork 0
mirror of https://github.com/bevyengine/bevy synced 2024-11-21 20:23:28 +00:00
Code Issues Projects Releases Packages Wiki Activity

Down with the system! (#2496)

Browse source 
# Objective

- Remove all the `.system()` possible.
- Check for remaining missing cases.

## Solution

- Remove all `.system()`, fix compile errors
- 32 calls to `.system()` remains, mostly internals, the few others should be removed after #2446
This commit is contained in:
François 2021-07-27 23:42:36 +00:00
parent 234b2efa71
commit b724a0f586
125 changed files with 544 additions and 732 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
benches/benches/bevy_ecs/stages.rs
View file

@ -1,7 +1,7 @@
use bevy::ecs::{
world::World,
schedule::{Stage, SystemStage},
system::{IntoSystem, Query},
world::World,
};
use criterion::{criterion_group, criterion_main, Criterion};
@ -29,7 +29,7 @@ fn empty_systems(criterion: &mut Criterion) {
for amount in 0..5 {
let mut stage = SystemStage::parallel();
for _ in 0..amount {
stage.add_system(empty.system());
stage.add_system(empty);
}
run_stage(&mut stage, &mut world);
group.bench_function(&format!("{:03}_systems", amount), |bencher| {
@ -42,11 +42,11 @@ fn empty_systems(criterion: &mut Criterion) {
let mut stage = SystemStage::parallel();
for _ in 0..amount {
stage
.add_system(empty.system())
.add_system(empty.system())
.add_system(empty.system())
.add_system(empty.system())
.add_system(empty.system());
.add_system(empty)
.add_system(empty)
.add_system(empty)
.add_system(empty)
.add_system(empty);
}
run_stage(&mut stage, &mut world);
group.bench_function(&format!("{:03}_systems", 5 * amount), |bencher| {
@ -85,15 +85,9 @@ fn busy_systems(criterion: &mut Criterion) {
world.spawn_batch((0..ENTITY_BUNCH).map(|_| (A(0.0), B(0.0), C(0.0), E(0.0))));
for system_amount in 0..5 {
let mut stage = SystemStage::parallel();
stage
.add_system(ab.system())
.add_system(cd.system())
.add_system(ce.system());
stage.add_system(ab).add_system(cd).add_system(ce);
for _ in 0..system_amount {
stage
.add_system(ab.system())
.add_system(cd.system())
.add_system(ce.system());
stage.add_system(ab).add_system(cd).add_system(ce);
}
run_stage(&mut stage, &mut world);
group.bench_function(
@ -142,15 +136,9 @@ fn contrived(criterion: &mut Criterion) {
world.spawn_batch((0..ENTITY_BUNCH).map(|_| (C(0.0), D(0.0))));
for system_amount in 0..5 {
let mut stage = SystemStage::parallel();
stage
.add_system(s_0.system())
.add_system(s_1.system())
.add_system(s_2.system());
stage.add_system(s_0).add_system(s_1).add_system(s_2);
for _ in 0..system_amount {
stage
.add_system(s_0.system())
.add_system(s_1.system())
.add_system(s_2.system());
stage.add_system(s_0).add_system(s_1).add_system(s_2);
}
run_stage(&mut stage, &mut world);
group.bench_function(

12
crates/bevy_app/src/app.rs
View file

@ -1,7 +1,7 @@
use crate::{CoreStage, Events, Plugin, PluginGroup, PluginGroupBuilder, StartupStage};
use bevy_ecs::{
component::{Component, ComponentDescriptor},
prelude::{FromWorld, IntoExclusiveSystem, IntoSystem},
prelude::{FromWorld, IntoExclusiveSystem},
schedule::{
IntoSystemDescriptor, RunOnce, Schedule, Stage, StageLabel, State, SystemSet, SystemStage,
},
@ -28,7 +28,7 @@ use bevy_utils::tracing::info_span;
///
/// fn main() {
/// App::new()
/// .add_system(hello_world_system.system())
/// .add_system(hello_world_system)
/// .run();
/// }
///
@ -180,7 +180,7 @@ impl App {
/// Adds a system that runs every time `app.update()` is called by the runner
///
/// Systems are the main building block in the Bevy ECS app model. You can define
/// normal rust functions, and call `.system()` to make them be Bevy systems.
/// normal rust functions, and use them as a Bevy system.
///
/// System functions can have parameters, through which one can query and
/// mutate Bevy ECS states.
@ -201,7 +201,7 @@ impl App {
/// }
///
/// App::new()
/// .add_system(my_system.system());
/// .add_system(my_system);
/// ```
pub fn add_system<Params>(&mut self, system: impl IntoSystemDescriptor<Params>) -> &mut Self {
self.add_system_to_stage(CoreStage::Update, system)
@ -248,7 +248,7 @@ impl App {
/// }
///
/// App::new()
/// .add_startup_system(my_startup_system.system());
/// .add_startup_system(my_startup_system);
/// ```
pub fn add_startup_system<Params>(
&mut self,
@ -335,7 +335,7 @@ impl App {
T: Component,
{
self.insert_resource(Events::<T>::default())
.add_system_to_stage(CoreStage::First, Events::<T>::update_system.system())
.add_system_to_stage(CoreStage::First, Events::<T>::update_system)
}
/// Inserts a resource to the current [App] and overwrites any resource previously added of the same type.

3
crates/bevy_app/src/ci_testing.rs
View file

@ -1,7 +1,6 @@
use serde::Deserialize;
use crate::{app::AppExit, App};
use bevy_ecs::system::IntoSystem;
/// Configuration for automated testing on CI
#[derive(Deserialize)]
@ -32,7 +31,7 @@ pub(crate) fn setup_app(app_builder: &mut App) -> &mut App {
.expect("error deserializing CI testing configuration file");
app_builder
.insert_resource(config)
.add_system(ci_testing_exit_after.system());
.add_system(ci_testing_exit_after);
app_builder
}

15
crates/bevy_asset/src/assets.rs
View file

@ -3,10 +3,7 @@ use crate::{
RefChange,
};
use bevy_app::{App, EventWriter, Events};
use bevy_ecs::{
system::{IntoSystem, ResMut},
world::FromWorld,
};
use bevy_ecs::{system::ResMut, world::FromWorld};
use bevy_utils::HashMap;
use crossbeam_channel::Sender;
use std::fmt::Debug;
@ -217,14 +214,8 @@ impl AddAsset for App {
};
self.insert_resource(assets)
.add_system_to_stage(
AssetStage::AssetEvents,
Assets::<T>::asset_event_system.system(),
)
.add_system_to_stage(
AssetStage::LoadAssets,
update_asset_storage_system::<T>.system(),
)
.add_system_to_stage(AssetStage::AssetEvents, Assets::<T>::asset_event_system)
.add_system_to_stage(AssetStage::LoadAssets, update_asset_storage_system::<T>)
.register_type::<Handle<T>>()
.add_event::<AssetEvent<T>>()
}

6
crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs
View file

@ -1,7 +1,7 @@
use crate::{Asset, Assets};
use bevy_app::prelude::*;
use bevy_diagnostic::{Diagnostic, DiagnosticId, Diagnostics, MAX_DIAGNOSTIC_NAME_WIDTH};
use bevy_ecs::system::{IntoSystem, Res, ResMut};
use bevy_ecs::system::{Res, ResMut};
/// Adds "asset count" diagnostic to an App
pub struct AssetCountDiagnosticsPlugin<T: Asset> {
@ -18,8 +18,8 @@ impl<T: Asset> Default for AssetCountDiagnosticsPlugin<T> {
impl<T: Asset> Plugin for AssetCountDiagnosticsPlugin<T> {
fn build(&self, app: &mut App) {
app.add_startup_system(Self::setup_system.system())
.add_system(Self::diagnostic_system.system());
app.add_startup_system(Self::setup_system)
.add_system(Self::diagnostic_system);
}
}

12
crates/bevy_asset/src/lib.rs
View file

@ -27,10 +27,7 @@ pub use loader::*;
pub use path::*;
use bevy_app::{prelude::Plugin, App};
use bevy_ecs::{
schedule::{StageLabel, SystemStage},
system::IntoSystem,
};
use bevy_ecs::schedule::{StageLabel, SystemStage};
use bevy_tasks::IoTaskPool;
/// The names of asset stages in an App Schedule
@ -106,16 +103,13 @@ impl Plugin for AssetPlugin {
.register_type::<HandleId>()
.add_system_to_stage(
bevy_app::CoreStage::PreUpdate,
asset_server::free_unused_assets_system.system(),
asset_server::free_unused_assets_system,
);
#[cfg(all(
feature = "filesystem_watcher",
all(not(target_arch = "wasm32"), not(target_os = "android"))
))]
app.add_system_to_stage(
AssetStage::LoadAssets,
io::filesystem_watcher_system.system(),
);
app.add_system_to_stage(AssetStage::LoadAssets, io::filesystem_watcher_system);
}
}

3
crates/bevy_core/src/label.rs
View file

@ -123,7 +123,6 @@ pub(crate) fn entity_labels_system(
mod tests {
use bevy_ecs::{
schedule::{Schedule, Stage, SystemStage},
system::IntoSystem,
world::World,
};
@ -134,7 +133,7 @@ mod tests {
world.insert_resource(EntityLabels::default());
let mut schedule = Schedule::default();
schedule.add_stage("test", SystemStage::single_threaded());
schedule.add_system_to_stage("test", entity_labels_system.system());
schedule.add_system_to_stage("test", entity_labels_system);
(world, schedule)
}

6
crates/bevy_core/src/lib.rs
View file

@ -21,7 +21,7 @@ use bevy_app::prelude::*;
use bevy_ecs::{
entity::Entity,
schedule::{ExclusiveSystemDescriptorCoercion, SystemLabel},
system::{IntoExclusiveSystem, IntoSystem},
system::IntoExclusiveSystem,
};
use bevy_utils::HashSet;
use std::ops::Range;
@ -62,8 +62,8 @@ impl Plugin for CorePlugin {
CoreStage::First,
time_system.exclusive_system().label(CoreSystem::Time),
)
.add_startup_system_to_stage(StartupStage::PostStartup, entity_labels_system.system())
.add_system_to_stage(CoreStage::PostUpdate, entity_labels_system.system());
.add_startup_system_to_stage(StartupStage::PostStartup, entity_labels_system)
.add_system_to_stage(CoreStage::PostUpdate, entity_labels_system);
register_rust_types(app);
register_math_types(app);

9
crates/bevy_core/src/time/fixed_timestep.rs
View file

@ -4,7 +4,7 @@ use bevy_ecs::{
component::ComponentId,
query::Access,
schedule::ShouldRun,
system::{IntoSystem, Local, Res, ResMut, System, SystemId},
system::{ConfigurableSystem, IntoSystem, Local, Res, ResMut, System, SystemId},
world::World,
};
use bevy_utils::HashMap;
@ -179,11 +179,8 @@ impl System for FixedTimestep {
}
fn initialize(&mut self, world: &mut World) {
self.internal_system = Box::new(
Self::prepare_system
.system()
.config(|c| c.0 = Some(self.state.clone())),
);
self.internal_system =
Box::new(Self::prepare_system.config(|c| c.0 = Some(self.state.clone())));
self.internal_system.initialize(world);
if let Some(ref label) = self.state.label {
let mut fixed_timesteps = world.get_resource_mut::<FixedTimesteps>().unwrap();

4
crates/bevy_diagnostic/src/entity_count_diagnostics_plugin.rs
View file

@ -1,6 +1,6 @@
use bevy_app::{App, Plugin};
use bevy_ecs::{
system::{IntoExclusiveSystem, IntoSystem, ResMut},
system::{IntoExclusiveSystem, ResMut},
world::World,
};
@ -12,7 +12,7 @@ pub struct EntityCountDiagnosticsPlugin;
impl Plugin for EntityCountDiagnosticsPlugin {
fn build(&self, app: &mut App) {
app.add_startup_system(Self::setup_system.system())
app.add_startup_system(Self::setup_system)
.add_system(Self::diagnostic_system.exclusive_system());
}
}

6
crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
View file

@ -1,7 +1,7 @@
use crate::{Diagnostic, DiagnosticId, Diagnostics};
use bevy_app::prelude::*;
use bevy_core::Time;
use bevy_ecs::system::{IntoSystem, Res, ResMut};
use bevy_ecs::system::{Res, ResMut};
/// Adds "frame time" diagnostic to an App, specifically "frame time", "fps" and "frame count"
#[derive(Default)]
@ -13,9 +13,9 @@ pub struct FrameTimeDiagnosticsState {
impl Plugin for FrameTimeDiagnosticsPlugin {
fn build(&self, app: &mut bevy_app::App) {
app.add_startup_system(Self::setup_system.system())
app.add_startup_system(Self::setup_system)
.insert_resource(FrameTimeDiagnosticsState { frame_count: 0.0 })
.add_system(Self::diagnostic_system.system());
.add_system(Self::diagnostic_system);
}
}

9
crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
View file

@ -1,7 +1,7 @@
use super::{Diagnostic, DiagnosticId, Diagnostics};
use bevy_app::prelude::*;
use bevy_core::{Time, Timer};
use bevy_ecs::system::{IntoSystem, Res, ResMut};
use bevy_ecs::system::{Res, ResMut};
use bevy_log::{debug, info};
use bevy_utils::Duration;
@ -36,12 +36,9 @@ impl Plugin for LogDiagnosticsPlugin {
});
if self.debug {
app.add_system_to_stage(
CoreStage::PostUpdate,
Self::log_diagnostics_debug_system.system(),
);
app.add_system_to_stage(CoreStage::PostUpdate, Self::log_diagnostics_debug_system);
} else {
app.add_system_to_stage(CoreStage::PostUpdate, Self::log_diagnostics_system.system());
app.add_system_to_stage(CoreStage::PostUpdate, Self::log_diagnostics_system);
}
}
}

2
crates/bevy_ecs/README.md
View file

@ -131,7 +131,7 @@ fn main() {
// Add a Stage to our schedule. Each Stage in a schedule runs all of its systems
// before moving on to the next Stage
schedule.add_stage("update", SystemStage::parallel()
.with_system(movement.system())
.with_system(movement)
);
// Run the schedule once. If your app has a "loop", you would run this once per loop

14
crates/bevy_ecs/examples/change_detection.rs
View file

@ -24,15 +24,11 @@ fn main() {
// Add systems to the Stage to execute our app logic
// We can label our systems to force a specific run-order between some of them
update.add_system(spawn_entities.system().label(SimulationSystem::Spawn));
update.add_system(
print_counter_when_changed
.system()
.after(SimulationSystem::Spawn),
);
update.add_system(age_all_entities.system().label(SimulationSystem::Age));
update.add_system(remove_old_entities.system().after(SimulationSystem::Age));
update.add_system(print_changed_entities.system().after(SimulationSystem::Age));
update.add_system(spawn_entities.label(SimulationSystem::Spawn));
update.add_system(print_counter_when_changed.after(SimulationSystem::Spawn));
update.add_system(age_all_entities.label(SimulationSystem::Age));
update.add_system(remove_old_entities.after(SimulationSystem::Age));
update.add_system(print_changed_entities.after(SimulationSystem::Age));
// Add the Stage with our systems to the Schedule
schedule.add_stage("update", update);

2
crates/bevy_ecs/examples/component_storage.rs
View file

@ -22,7 +22,7 @@ fn main() {
// Setup a schedule and stage to add a system querying for the just spawned entities
let mut schedule = Schedule::default();
let mut update = SystemStage::parallel();
update.add_system(query_entities.system());
update.add_system(query_entities);
schedule.add_stage("update", update);
schedule.run(&mut world);

6
crates/bevy_ecs/examples/events.rs
View file

@ -16,13 +16,13 @@ fn main() {
// called "second". In "first" we update the events and in "second" we run our systems
// sending and receiving events.
let mut first = SystemStage::parallel();
first.add_system(Events::<MyEvent>::update_system.system());
first.add_system(Events::<MyEvent>::update_system);
schedule.add_stage("first", first);
// Add systems sending and receiving events to a "second" Stage
let mut second = SystemStage::parallel();
second.add_system(sending_system.system().label(EventSystem::Sending));
second.add_system(receiving_system.system().after(EventSystem::Sending));
second.add_system(sending_system.label(EventSystem::Sending));
second.add_system(receiving_system.after(EventSystem::Sending));
// Run the "second" Stage after the "first" Stage, so our Events always get updated before we use them
schedule.add_stage_after("first", "second", second);

4
crates/bevy_ecs/examples/resources.rs
View file

@ -16,8 +16,8 @@ fn main() {
let mut update = SystemStage::parallel();
// Add systems to increase the counter and to print out the current value
update.add_system(increase_counter.system().label(CounterSystem::Increase));
update.add_system(print_counter.system().after(CounterSystem::Increase));
update.add_system(increase_counter.label(CounterSystem::Increase));
update.add_system(print_counter.after(CounterSystem::Increase));
schedule.add_stage("update", update);
for iteration in 1..=10 {

48
crates/bevy_ecs/src/schedule/executor_parallel.rs
View file

@ -316,7 +316,7 @@ mod tests {
use super::SchedulingEvent::{self, *};
use crate::{
schedule::{SingleThreadedExecutor, Stage, SystemStage},
system::{IntoSystem, NonSend, Query, Res, ResMut},
system::{NonSend, Query, Res, ResMut},
world::World,
};
use async_channel::Receiver;
@ -338,9 +338,9 @@ mod tests {
let mut world = World::new();
fn wants_for_nothing() {}
let mut stage = SystemStage::parallel()
.with_system(wants_for_nothing.system())
.with_system(wants_for_nothing.system())
.with_system(wants_for_nothing.system());
.with_system(wants_for_nothing)
.with_system(wants_for_nothing)
.with_system(wants_for_nothing);
stage.run(&mut world);
stage.run(&mut world);
assert_eq!(
@ -356,24 +356,24 @@ mod tests {
fn wants_mut(_: ResMut<usize>) {}
fn wants_ref(_: Res<usize>) {}
let mut stage = SystemStage::parallel()
.with_system(wants_mut.system())
.with_system(wants_mut.system());
.with_system(wants_mut)
.with_system(wants_mut);
stage.run(&mut world);
assert_eq!(
receive_events(&world),
vec![StartedSystems(1), StartedSystems(1),]
);
let mut stage = SystemStage::parallel()
.with_system(wants_mut.system())
.with_system(wants_ref.system());
.with_system(wants_mut)
.with_system(wants_ref);
stage.run(&mut world);
assert_eq!(
receive_events(&world),
vec![StartedSystems(1), StartedSystems(1),]
);
let mut stage = SystemStage::parallel()
.with_system(wants_ref.system())
.with_system(wants_ref.system());
.with_system(wants_ref)
.with_system(wants_ref);
stage.run(&mut world);
assert_eq!(receive_events(&world), vec![StartedSystems(2),]);
}
@ -385,24 +385,24 @@ mod tests {
fn wants_mut(_: Query<&mut usize>) {}
fn wants_ref(_: Query<&usize>) {}
let mut stage = SystemStage::parallel()
.with_system(wants_mut.system())
.with_system(wants_mut.system());
.with_system(wants_mut)
.with_system(wants_mut);
stage.run(&mut world);
assert_eq!(
receive_events(&world),
vec![StartedSystems(1), StartedSystems(1),]
);
let mut stage = SystemStage::parallel()
.with_system(wants_mut.system())
.with_system(wants_ref.system());
.with_system(wants_mut)
.with_system(wants_ref);
stage.run(&mut world);
assert_eq!(
receive_events(&world),
vec![StartedSystems(1), StartedSystems(1),]
);
let mut stage = SystemStage::parallel()
.with_system(wants_ref.system())
.with_system(wants_ref.system());
.with_system(wants_ref)
.with_system(wants_ref);
stage.run(&mut world);
assert_eq!(receive_events(&world), vec![StartedSystems(2),]);
let mut world = World::new();
@ -410,8 +410,8 @@ mod tests {
fn wants_mut_usize(_: Query<(&mut usize, &f32)>) {}
fn wants_mut_u32(_: Query<(&mut u32, &f32)>) {}
let mut stage = SystemStage::parallel()
.with_system(wants_mut_usize.system())
.with_system(wants_mut_u32.system());
.with_system(wants_mut_usize)
.with_system(wants_mut_u32);
stage.run(&mut world);
assert_eq!(receive_events(&world), vec![StartedSystems(2),]);
}
@ -426,12 +426,12 @@ mod tests {
}
fn empty() {}
let mut stage = SystemStage::parallel()
.with_system(non_send.system())
.with_system(non_send.system())
.with_system(empty.system())
.with_system(empty.system())
.with_system(non_send.system())
.with_system(non_send.system());
.with_system(non_send)
.with_system(non_send)
.with_system(empty)
.with_system(empty)
.with_system(non_send)
.with_system(non_send);
stage.run(&mut world);
assert_eq!(
receive_events(&world),

7
crates/bevy_ecs/src/schedule/mod.rs
View file

@ -22,10 +22,7 @@ pub use system_set::*;
use std::fmt::Debug;
use crate::{
system::{IntoSystem, System},
world::World,
};
use crate::{system::System, world::World};
use bevy_utils::HashMap;
#[derive(Default)]
@ -79,7 +76,7 @@ impl Schedule {
&mut self,
system: S,
) -> &mut Self {
self.run_criteria.set(Box::new(system.system()));
self.run_criteria.set(Box::new(system));
self
}

351
crates/bevy_ecs/src/schedule/stage.rs
View file

@ -1,5 +1,6 @@
use crate::{
component::ComponentId,
prelude::IntoSystem,
schedule::{
graph_utils::{self, DependencyGraphError},
BoxedRunCriteria, BoxedRunCriteriaLabel, BoxedSystemLabel, DuplicateLabelStrategy,
@ -8,7 +9,6 @@ use crate::{
RunCriteriaDescriptor, RunCriteriaDescriptorOrLabel, RunCriteriaInner, ShouldRun,
SingleThreadedExecutor, SystemContainer, SystemDescriptor, SystemSet,
},
system::System,
world::{World, WorldId},
};
use bevy_utils::{tracing::info, HashMap, HashSet};
@ -289,16 +289,19 @@ impl SystemStage {
self
}
pub fn with_run_criteria<S: System<In = (), Out = ShouldRun>>(mut self, system: S) -> Self {
self.set_run_criteria(system);
pub fn with_run_criteria<Param, S: IntoSystem<(), ShouldRun, Param>>(
mut self,
system: S,
) -> Self {
self.set_run_criteria(system.system());
self
}
pub fn set_run_criteria<S: System<In = (), Out = ShouldRun>>(
pub fn set_run_criteria<Param, S: IntoSystem<(), ShouldRun, Param>>(
&mut self,
system: S,
) -> &mut Self {
self.stage_run_criteria.set(Box::new(system));
self.stage_run_criteria.set(Box::new(system.system()));
self
}
@ -905,14 +908,8 @@ mod tests {
move |world| world.get_resource_mut::<Vec<usize>>().unwrap().push(tag)
}
// This is silly. https://github.com/bevyengine/bevy/issues/1029
macro_rules! make_parallel {
($tag:expr) => {{
fn parallel(mut resource: ResMut<Vec<usize>>) {
resource.push($tag)
}
parallel
}};
fn make_parallel(tag: usize) -> impl FnMut(ResMut<Vec<usize>>) {
move |mut resource: ResMut<Vec<usize>>| resource.push(tag)
}
fn every_other_time(mut has_ran: Local<bool>) -> ShouldRun {
@ -930,7 +927,7 @@ mod tests {
world.insert_resource(Vec::<usize>::new());
let mut stage = SystemStage::parallel()
.with_system(make_exclusive(0).exclusive_system().at_start())
.with_system(make_parallel!(1).system())
.with_system(make_parallel(1))
.with_system(make_exclusive(2).exclusive_system().before_commands())
.with_system(make_exclusive(3).exclusive_system().at_end());
stage.run(&mut world);
@ -949,7 +946,7 @@ mod tests {
let mut stage = SystemStage::parallel()
.with_system(make_exclusive(2).exclusive_system().before_commands())
.with_system(make_exclusive(3).exclusive_system().at_end())
.with_system(make_parallel!(1).system())
.with_system(make_parallel(1))
.with_system(make_exclusive(0).exclusive_system().at_start());
stage.run(&mut world);
assert_eq!(
@ -965,10 +962,10 @@ mod tests {
world.get_resource_mut::<Vec<usize>>().unwrap().clear();
let mut stage = SystemStage::parallel()
.with_system(make_parallel!(2).exclusive_system().before_commands())
.with_system(make_parallel!(3).exclusive_system().at_end())
.with_system(make_parallel!(1).system())
.with_system(make_parallel!(0).exclusive_system().at_start());
.with_system(make_parallel(2).exclusive_system().before_commands())
.with_system(make_parallel(3).exclusive_system().at_end())
.with_system(make_parallel(1))
.with_system(make_parallel(0).exclusive_system().at_start());
stage.run(&mut world);
assert_eq!(
*world.get_resource::<Vec<usize>>().unwrap(),
@ -1225,9 +1222,9 @@ mod tests {
let mut world = World::new();
world.insert_resource(Vec::<usize>::new());
let mut stage = SystemStage::parallel()
.with_system(make_parallel!(1).system().after("0").label("1"))
.with_system(make_parallel!(2).system().after("1"))
.with_system(make_parallel!(0).system().label("0"));
.with_system(make_parallel(1).after("0").label("1"))
.with_system(make_parallel(2).after("1"))
.with_system(make_parallel(0).label("0"));
stage.run(&mut world);
stage.set_executor(Box::new(SingleThreadedExecutor::default()));
stage.run(&mut world);
@ -1242,9 +1239,9 @@ mod tests {
let mut world = World::new();
world.insert_resource(Vec::<usize>::new());
let mut stage = SystemStage::parallel()
.with_system(make_parallel!(1).system().label("1").before("2"))
.with_system(make_parallel!(2).system().label("2"))
.with_system(make_parallel!(0).system().before("1"));
.with_system(make_parallel(1).label("1").before("2"))
.with_system(make_parallel(2).label("2"))
.with_system(make_parallel(0).before("1"));
stage.run(&mut world);
stage.set_executor(Box::new(SingleThreadedExecutor::default()));
stage.run(&mut world);
@ -1259,11 +1256,11 @@ mod tests {
let mut world = World::new();
world.insert_resource(Vec::<usize>::new());
let mut stage = SystemStage::parallel()
.with_system(make_parallel!(2).system().label("2"))
.with_system(make_parallel!(1).system().after("0").before("2"))
.with_system(make_parallel!(0).system().label("0"))
.with_system(make_parallel!(4).system().label("4"))
.with_system(make_parallel!(3).system().after("2").before("4"));
.with_system(make_parallel(2).label("2"))
.with_system(make_parallel(1).after("0").before("2"))
.with_system(make_parallel(0).label("0"))
.with_system(make_parallel(4).label("4"))
.with_system(make_parallel(3).after("2").before("4"));
stage.run(&mut world);
stage.set_executor(Box::new(SingleThreadedExecutor::default()));
stage.run(&mut world);
@ -1278,9 +1275,9 @@ mod tests {
let mut world = World::new();
world.insert_resource(Vec::<usize>::new());
let mut stage = SystemStage::parallel()
.with_system(make_parallel!(1).system().label("first").after("0"))
.with_system(make_parallel!(2).system().after("first"))
.with_system(make_parallel!(0).system().label("first").label("0"));
.with_system(make_parallel(1).label("first").after("0"))
.with_system(make_parallel(2).after("first"))
.with_system(make_parallel(0).label("first").label("0"));
stage.run(&mut world);
stage.set_executor(Box::new(SingleThreadedExecutor::default()));
stage.run(&mut world);
@ -1291,11 +1288,11 @@ mod tests {
world.get_resource_mut::<Vec<usize>>().unwrap().clear();
let mut stage = SystemStage::parallel()
.with_system(make_parallel!(2).system().after("01").label("2"))
.with_system(make_parallel!(1).system().label("01").after("0"))
.with_system(make_parallel!(0).system().label("01").label("0"))
.with_system(make_parallel!(4).system().label("4"))
.with_system(make_parallel!(3).system().after("2").before("4"));
.with_system(make_parallel(2).after("01").label("2"))
.with_system(make_parallel(1).label("01").after("0"))
.with_system(make_parallel(0).label("01").label("0"))
.with_system(make_parallel(4).label("4"))
.with_system(make_parallel(3).after("2").before("4"));
stage.run(&mut world);
stage.set_executor(Box::new(SingleThreadedExecutor::default()));
stage.run(&mut world);
@ -1306,17 +1303,11 @@ mod tests {
world.get_resource_mut::<Vec<usize>>().unwrap().clear();
let mut stage = SystemStage::parallel()
.with_system(make_parallel!(2).system().label("234").label("2"))
.with_system(make_parallel!(1).system().before("234").after("0"))
.with_system(make_parallel!(0).system().label("0"))
.with_system(make_parallel!(4).system().label("234").label("4"))
.with_system(
make_parallel!(3)
.system()
.label("234")
.after("2")
.before("4"),
);
.with_system(make_parallel(2).label("234").label("2"))
.with_system(make_parallel(1).before("234").after("0"))
.with_system(make_parallel(0).label("0"))
.with_system(make_parallel(4).label("234").label("4"))
.with_system(make_parallel(3).label("234").after("2").before("4"));
stage.run(&mut world);
stage.set_executor(Box::new(SingleThreadedExecutor::default()));
stage.run(&mut world);
@ -1332,24 +1323,22 @@ mod tests {
world.insert_resource(Vec::<usize>::new());
let mut stage = SystemStage::parallel()
.with_system(
make_parallel!(2)
.system()
make_parallel(2)
.label("2")
.after("1")
.before("3")
.before("3"),
)
.with_system(
make_parallel!(1)
.system()
make_parallel(1)
.label("1")
.after("0")
.after("0")
.before("2"),
)
.with_system(make_parallel!(0).system().label("0").before("1"))
.with_system(make_parallel!(4).system().label("4").after("3"))
.with_system(make_parallel!(3).system().label("3").after("2").before("4"));
.with_system(make_parallel(0).label("0").before("1"))
.with_system(make_parallel(4).label("4").after("3"))
.with_system(make_parallel(3).label("3").after("2").before("4"));
stage.run(&mut world);
for container in stage.parallel.iter() {
assert!(container.dependencies().len() <= 1);
@ -1367,14 +1356,14 @@ mod tests {
let mut world = World::new();
world.insert_resource(Vec::<usize>::new());
let mut stage = SystemStage::parallel()
.with_system(make_parallel!(2).system().label("2"))
.with_system(make_parallel(2).label("2"))
.with_system_set(
SystemSet::new()
.with_system(make_parallel!(0).system().label("0"))
.with_system(make_parallel!(4).system().label("4"))
.with_system(make_parallel!(3).system().after("2").before("4")),
.with_system(make_parallel(0).label("0"))
.with_system(make_parallel(4).label("4"))
.with_system(make_parallel(3).after("2").before("4")),
)
.with_system(make_parallel!(1).system().after("0").before("2"));
.with_system(make_parallel(1).after("0").before("2"));
stage.run(&mut world);
stage.set_executor(Box::new(SingleThreadedExecutor::default()));
stage.run(&mut world);
@ -1391,12 +1380,11 @@ mod tests {
world.insert_resource(Vec::<usize>::new());
let mut stage = SystemStage::parallel()
.with_system(
make_parallel!(0)
.system()
make_parallel(0)
.label("0")
.with_run_criteria(every_other_time),
)
.with_system(make_parallel!(1).system().after("0"));
.with_system(make_parallel(1).after("0"));
stage.run(&mut world);
stage.run(&mut world);
stage.set_executor(Box::new(SingleThreadedExecutor::default()));
@ -1409,13 +1397,13 @@ mod tests {
world.get_resource_mut::<Vec<usize>>().unwrap().clear();
let mut stage = SystemStage::parallel()
.with_system(make_parallel!(0).system().before("1"))
.with_system(make_parallel(0).before("1"))
.with_system_set(
SystemSet::new()
.with_run_criteria(every_other_time.system())
.with_system(make_parallel!(1).system().label("1")),
.with_run_criteria(every_other_time)
.with_system(make_parallel(1).label("1")),
)
.with_system(make_parallel!(2).system().after("1"));
.with_system(make_parallel(2).after("1"));
stage.run(&mut world);
stage.run(&mut world);
stage.set_executor(Box::new(SingleThreadedExecutor::default()));
@ -1430,21 +1418,19 @@ mod tests {
world.get_resource_mut::<Vec<usize>>().unwrap().clear();
let mut stage = SystemStage::parallel()
.with_system_run_criteria(every_other_time.label("every other time"))
.with_system(make_parallel!(0).system().before("1"))
.with_system(make_parallel(0).before("1"))
.with_system(
make_parallel!(1)
.system()
make_parallel(1)
.label("1")
.with_run_criteria("every other time"),
)
.with_system(
make_parallel!(2)
.system()
make_parallel(2)
.label("2")
.after("1")
.with_run_criteria("every other time"),
)
.with_system(make_parallel!(3).system().after("2"));
.with_system(make_parallel(3).after("2"));
stage.run(&mut world);
stage.run(&mut world);
stage.set_executor(Box::new(SingleThreadedExecutor::default()));
@ -1466,34 +1452,26 @@ mod tests {
}
}
let mut stage = SystemStage::parallel()
.with_system(make_parallel!(0).system().label("0"))
.with_system(make_parallel(0).label("0"))
.with_system(
make_parallel!(1)
.system()
make_parallel(1)
.label("1")
.after("0")
.with_run_criteria(every_other_time.system().label("every other time")),
.with_run_criteria(every_other_time.label("every other time")),
)
.with_system(
make_parallel!(2)
.system()
make_parallel(2)
.label("2")
.after("1")
.with_run_criteria(RunCriteria::pipe("every other time", eot_piped.system())),
)
.with_system(
make_parallel!(3)
.system()
make_parallel(3)
.label("3")
.after("2")
.with_run_criteria("every other time".pipe(eot_piped.system()).label("piped")),
)
.with_system(
make_parallel!(4)
.system()
.after("3")
.with_run_criteria("piped"),
);
.with_system(make_parallel(4).after("3").with_run_criteria("piped"));
for _ in 0..4 {
stage.run(&mut world);
}
@ -1509,27 +1487,16 @@ mod tests {
// Discarding extra criteria with matching labels.
world.get_resource_mut::<Vec<usize>>().unwrap().clear();
let mut stage = SystemStage::parallel()
.with_system(make_parallel!(0).system().before("1"))
.with_system(
make_parallel!(1).system().label("1").with_run_criteria(
every_other_time
.system()
.label_discard_if_duplicate("every other time"),
),
)
.with_system(
make_parallel!(2)
.system()
.label("2")
.after("1")
.with_run_criteria(
every_other_time
.system()
.label_discard_if_duplicate("every other time"),
),
)
.with_system(make_parallel!(3).system().after("2"));
let mut stage =
SystemStage::parallel()
.with_system(make_parallel(0).before("1"))
.with_system(make_parallel(1).label("1").with_run_criteria(
every_other_time.label_discard_if_duplicate("every other time"),
))
.with_system(make_parallel(2).label("2").after("1").with_run_criteria(
every_other_time.label_discard_if_duplicate("every other time"),
))
.with_system(make_parallel(3).after("2"));
stage.run(&mut world);
stage.run(&mut world);
stage.set_executor(Box::new(SingleThreadedExecutor::default()));
@ -1547,8 +1514,8 @@ mod tests {
fn duplicate_run_criteria_label_panic() {
let mut world = World::new();
let mut stage = SystemStage::parallel()
.with_system_run_criteria(every_other_time.system().label("every other time"))
.with_system_run_criteria(every_other_time.system().label("every other time"));
.with_system_run_criteria(every_other_time.label("every other time"))
.with_system_run_criteria(every_other_time.label("every other time"));
stage.run(&mut world);
}
@ -1557,8 +1524,7 @@ mod tests {
fn parallel_cycle_1() {
let mut world = World::new();
world.insert_resource(Vec::<usize>::new());
let mut stage =
SystemStage::parallel().with_system(make_parallel!(0).system().label("0").after("0"));
let mut stage = SystemStage::parallel().with_system(make_parallel(0).label("0").after("0"));
stage.run(&mut world);
}
@ -1568,8 +1534,8 @@ mod tests {
let mut world = World::new();
world.insert_resource(Vec::<usize>::new());
let mut stage = SystemStage::parallel()
.with_system(make_parallel!(0).system().label("0").after("1"))
.with_system(make_parallel!(1).system().label("1").after("0"));
.with_system(make_parallel(0).label("0").after("1"))
.with_system(make_parallel(1).label("1").after("0"));
stage.run(&mut world);
}
@ -1580,9 +1546,9 @@ mod tests {
world.insert_resource(Vec::<usize>::new());
let mut stage = SystemStage::parallel()
.with_system(make_parallel!(0).system().label("0"))
.with_system(make_parallel!(1).system().after("0").before("2"))
.with_system(make_parallel!(2).system().label("2").before("0"));
.with_system(make_parallel(0).label("0"))
.with_system(make_parallel(1).after("0").before("2"))
.with_system(make_parallel(2).label("2").before("0"));
stage.run(&mut world);
}
@ -1611,21 +1577,21 @@ mod tests {
let mut world = World::new();
let mut stage = SystemStage::parallel()
.with_system(empty.system().label("0"))
.with_system(empty.system().label("1").after("0"))
.with_system(empty.system().label("2"))
.with_system(empty.system().label("3").after("2").before("4"))
.with_system(empty.system().label("4"));
.with_system(empty.label("0"))
.with_system(empty.label("1").after("0"))
.with_system(empty.label("2"))
.with_system(empty.label("3").after("2").before("4"))
.with_system(empty.label("4"));
stage.initialize_systems(&mut world);
stage.rebuild_orders_and_dependencies();
assert_eq!(find_ambiguities(&stage.parallel).len(), 0);
let mut stage = SystemStage::parallel()
.with_system(empty.system().label("0"))
.with_system(component.system().label("1").after("0"))
.with_system(empty.system().label("2"))
.with_system(empty.system().label("3").after("2").before("4"))
.with_system(component.system().label("4"));
.with_system(empty.label("0"))
.with_system(component.label("1").after("0"))
.with_system(empty.label("2"))
.with_system(empty.label("3").after("2").before("4"))
.with_system(component.label("4"));
stage.initialize_systems(&mut world);
stage.rebuild_orders_and_dependencies();
let ambiguities = find_ambiguities_first_labels(&stage.parallel);
@ -1636,11 +1602,11 @@ mod tests {
assert_eq!(ambiguities.len(), 1);
let mut stage = SystemStage::parallel()
.with_system(empty.system().label("0"))
.with_system(resource.system().label("1").after("0"))
.with_system(empty.system().label("2"))
.with_system(empty.system().label("3").after("2").before("4"))
.with_system(resource.system().label("4"));
.with_system(empty.label("0"))
.with_system(resource.label("1").after("0"))
.with_system(empty.label("2"))
.with_system(empty.label("3").after("2").before("4"))
.with_system(resource.label("4"));
stage.initialize_systems(&mut world);
stage.rebuild_orders_and_dependencies();
let ambiguities = find_ambiguities_first_labels(&stage.parallel);
@ -1651,21 +1617,21 @@ mod tests {
assert_eq!(ambiguities.len(), 1);
let mut stage = SystemStage::parallel()
.with_system(empty.system().label("0"))
.with_system(resource.system().label("1").after("0"))
.with_system(empty.system().label("2"))
.with_system(empty.system().label("3").after("2").before("4"))
.with_system(component.system().label("4"));
.with_system(empty.label("0"))
.with_system(resource.label("1").after("0"))
.with_system(empty.label("2"))
.with_system(empty.label("3").after("2").before("4"))
.with_system(component.label("4"));
stage.initialize_systems(&mut world);
stage.rebuild_orders_and_dependencies();
assert_eq!(find_ambiguities(&stage.parallel).len(), 0);
let mut stage = SystemStage::parallel()
.with_system(component.system().label("0"))
.with_system(resource.system().label("1").after("0"))
.with_system(empty.system().label("2"))
.with_system(component.system().label("3").after("2").before("4"))
.with_system(resource.system().label("4"));
.with_system(component.label("0"))
.with_system(resource.label("1").after("0"))
.with_system(empty.label("2"))
.with_system(component.label("3").after("2").before("4"))
.with_system(resource.label("4"));
stage.initialize_systems(&mut world);
stage.rebuild_orders_and_dependencies();
let ambiguities = find_ambiguities_first_labels(&stage.parallel);
@ -1680,17 +1646,11 @@ mod tests {
assert_eq!(ambiguities.len(), 2);
let mut stage = SystemStage::parallel()
.with_system(component.system().label("0"))
.with_system(
resource
.system()
.label("1")
.after("0")
.in_ambiguity_set("a"),
)
.with_system(empty.system().label("2"))
.with_system(component.system().label("3").after("2").before("4"))
.with_system(resource.system().label("4").in_ambiguity_set("a"));
.with_system(component.label("0"))
.with_system(resource.label("1").after("0").in_ambiguity_set("a"))
.with_system(empty.label("2"))
.with_system(component.label("3").after("2").before("4"))
.with_system(resource.label("4").in_ambiguity_set("a"));
stage.initialize_systems(&mut world);
stage.rebuild_orders_and_dependencies();
let ambiguities = find_ambiguities_first_labels(&stage.parallel);
@ -1701,9 +1661,9 @@ mod tests {
assert_eq!(ambiguities.len(), 1);
let mut stage = SystemStage::parallel()
.with_system(component.system().label("0").before("2"))
.with_system(component.system().label("1").before("2"))
.with_system(component.system().label("2"));
.with_system(component.label("0").before("2"))
.with_system(component.label("1").before("2"))
.with_system(component.label("2"));
stage.initialize_systems(&mut world);
stage.rebuild_orders_and_dependencies();
let ambiguities = find_ambiguities_first_labels(&stage.parallel);
@ -1714,9 +1674,9 @@ mod tests {
assert_eq!(ambiguities.len(), 1);
let mut stage = SystemStage::parallel()
.with_system(component.system().label("0"))
.with_system(component.system().label("1").after("0"))
.with_system(component.system().label("2").after("0"));
.with_system(component.label("0"))
.with_system(component.label("1").after("0"))
.with_system(component.label("2").after("0"));
stage.initialize_systems(&mut world);
stage.rebuild_orders_and_dependencies();
let ambiguities = find_ambiguities_first_labels(&stage.parallel);
@ -1727,10 +1687,10 @@ mod tests {
assert_eq!(ambiguities.len(), 1);
let mut stage = SystemStage::parallel()
.with_system(component.system().label("0").before("1").before("2"))
.with_system(component.system().label("1"))
.with_system(component.system().label("2"))
.with_system(component.system().label("3").after("1").after("2"));
.with_system(component.label("0").before("1").before("2"))
.with_system(component.label("1"))
.with_system(component.label("2"))
.with_system(component.label("3").after("1").after("2"));
stage.initialize_systems(&mut world);
stage.rebuild_orders_and_dependencies();
let ambiguities = find_ambiguities_first_labels(&stage.parallel);
@ -1741,20 +1701,20 @@ mod tests {
assert_eq!(ambiguities.len(), 1);
let mut stage = SystemStage::parallel()
.with_system(component.system().label("0").before("1").before("2"))
.with_system(component.system().label("1").in_ambiguity_set("a"))
.with_system(component.system().label("2").in_ambiguity_set("a"))
.with_system(component.system().label("3").after("1").after("2"));
.with_system(component.label("0").before("1").before("2"))
.with_system(component.label("1").in_ambiguity_set("a"))
.with_system(component.label("2").in_ambiguity_set("a"))
.with_system(component.label("3").after("1").after("2"));
stage.initialize_systems(&mut world);
stage.rebuild_orders_and_dependencies();
let ambiguities = find_ambiguities_first_labels(&stage.parallel);
assert_eq!(ambiguities.len(), 0);
let mut stage = SystemStage::parallel()
.with_system(component.system().label("0").before("1").before("2"))
.with_system(component.system().label("1").in_ambiguity_set("a"))
.with_system(component.system().label("2").in_ambiguity_set("b"))
.with_system(component.system().label("3").after("1").after("2"));
.with_system(component.label("0").before("1").before("2"))
.with_system(component.label("1").in_ambiguity_set("a"))
.with_system(component.label("2").in_ambiguity_set("b"))
.with_system(component.label("3").after("1").after("2"));
stage.initialize_systems(&mut world);
stage.rebuild_orders_and_dependencies();
let ambiguities = find_ambiguities_first_labels(&stage.parallel);
@ -1767,20 +1727,18 @@ mod tests {
let mut stage = SystemStage::parallel()
.with_system(
component
.system()
.label("0")
.before("1")
.before("2")
.before("3")
.before("4"),
)
.with_system(component.system().label("1"))
.with_system(component.system().label("2"))
.with_system(component.system().label("3"))
.with_system(component.system().label("4"))
.with_system(component.label("1"))
.with_system(component.label("2"))
.with_system(component.label("3"))
.with_system(component.label("4"))
.with_system(
component
.system()
.label("5")
.after("1")
.after("2")
@ -1819,20 +1777,18 @@ mod tests {
let mut stage = SystemStage::parallel()
.with_system(
component
.system()
.label("0")
.before("1")
.before("2")
.before("3")
.before("4"),
)
.with_system(component.system().label("1").in_ambiguity_set("a"))
.with_system(component.system().label("2").in_ambiguity_set("a"))
.with_system(component.system().label("3").in_ambiguity_set("a"))
.with_system(component.system().label("4").in_ambiguity_set("a"))
.with_system(component.label("1").in_ambiguity_set("a"))
.with_system(component.label("2").in_ambiguity_set("a"))
.with_system(component.label("3").in_ambiguity_set("a"))
.with_system(component.label("4").in_ambiguity_set("a"))
.with_system(
component
.system()
.label("5")
.after("1")
.after("2")
@ -1847,26 +1803,23 @@ mod tests {
let mut stage = SystemStage::parallel()
.with_system(
component
.system()
.label("0")
.before("1")
.before("2")
.before("3")
.before("4"),
)
.with_system(component.system().label("1").in_ambiguity_set("a"))
.with_system(component.system().label("2").in_ambiguity_set("a"))
.with_system(component.label("1").in_ambiguity_set("a"))
.with_system(component.label("2").in_ambiguity_set("a"))
.with_system(
component
.system()
.label("3")
.in_ambiguity_set("a")
.in_ambiguity_set("b"),
)
.with_system(component.system().label("4").in_ambiguity_set("b"))
.with_system(component.label("4").in_ambiguity_set("b"))
.with_system(
component
.system()
.label("5")
.after("1")
.after("2")
@ -1997,7 +1950,7 @@ mod tests {
let mut world = World::new();
world.insert_resource(0_usize);
let mut stage = SystemStage::single(query_count_system.system());
let mut stage = SystemStage::single(query_count_system);
let entity = world.spawn().insert_bundle(()).id();
stage.run(&mut world);
@ -2020,7 +1973,7 @@ mod tests {
let mut world = World::new();
world.insert_resource(0_usize);
let mut stage = SystemStage::parallel();
stage.add_system(query_count_system.system());
stage.add_system(query_count_system);
let entity = world.spawn().insert_bundle(()).id();
stage.run(&mut world);
@ -2042,7 +1995,7 @@ mod tests {
let mut stage = SystemStage::parallel();
fn work() {}
stage.add_system(work.system());
stage.add_system(work);
// Overflow twice
for _ in 0..10 {
@ -2120,11 +2073,11 @@ mod tests {
let mut world = World::new();
world.insert_resource(Vec::<usize>::new());
let mut stage = SystemStage::parallel()
.with_system(spawn_entity.system().label("spawn"))
.with_system(spawn_entity.label("spawn"))
.with_system_set(
SystemSet::new()
.with_run_criteria(even_number_of_entities_critiera.system())
.with_system(count_entities.system().before("spawn")),
.with_run_criteria(even_number_of_entities_critiera)
.with_system(count_entities.before("spawn")),
);
stage.run(&mut world);
stage.run(&mut world);
@ -2155,10 +2108,10 @@ mod tests {
let mut world = World::new();
world.insert_resource(Vec::<usize>::new());
let mut stage_spawn = SystemStage::parallel().with_system(spawn_entity.system());
let mut stage_spawn = SystemStage::parallel().with_system(spawn_entity);
let mut stage_count = SystemStage::parallel()
.with_run_criteria(even_number_of_entities_critiera.system())
.with_system(count_entities.system());
.with_run_criteria(even_number_of_entities_critiera)
.with_system(count_entities);
stage_count.run(&mut world);
stage_spawn.run(&mut world);
stage_count.run(&mut world);

101
crates/bevy_ecs/src/schedule/state.rs
View file

@ -4,7 +4,7 @@ use crate::{
RunCriteriaDescriptor, RunCriteriaDescriptorCoercion, RunCriteriaLabel, ShouldRun,
SystemSet,
},
system::{In, IntoChainSystem, IntoSystem, Local, Res, ResMut},
system::{ConfigurableSystem, In, IntoChainSystem, Local, Res, ResMut},
};
use std::{any::TypeId, fmt::Debug, hash::Hash};
use thiserror::Error;
@ -97,9 +97,8 @@ where
(|state: Res<State<T>>, pred: Local<Option<T>>| {
state.stack.last().unwrap() == pred.as_ref().unwrap() && state.transition.is_none()
})
.system()
.config(|(_, pred)| *pred = Some(Some(s.clone())))
.chain(should_run_adapter::<T>.system())
.chain(should_run_adapter::<T>)
.after(DriverLabel::of::<T>())
.label_discard_if_duplicate(StateCallback::Update.into_label(s))
}
@ -118,9 +117,8 @@ where
Some(_) => false,
None => *is_inactive,
})
.system()
.config(|(_, _, pred)| *pred = Some(Some(s.clone())))
.chain(should_run_adapter::<T>.system())
.chain(should_run_adapter::<T>)
.after(DriverLabel::of::<T>())
.label_discard_if_duplicate(StateCallback::InactiveUpdate.into_label(s))
}
@ -151,9 +149,8 @@ where
Some(_) => false,
None => *is_in_stack,
})
.system()
.config(|(_, _, pred)| *pred = Some(Some(s.clone())))
.chain(should_run_adapter::<T>.system())
.chain(should_run_adapter::<T>)
.after(DriverLabel::of::<T>())
.label_discard_if_duplicate(StateCallback::InStackUpdate.into_label(s))
}
@ -171,9 +168,8 @@ where
_ => false,
})
})
.system()
.config(|(_, pred)| *pred = Some(Some(s.clone())))
.chain(should_run_adapter::<T>.system())
.chain(should_run_adapter::<T>)
.after(DriverLabel::of::<T>())
.label_discard_if_duplicate(StateCallback::Enter.into_label(s))
}
@ -189,9 +185,8 @@ where
_ => false,
})
})
.system()
.config(|(_, pred)| *pred = Some(Some(s.clone())))
.chain(should_run_adapter::<T>.system())
.chain(should_run_adapter::<T>)
.after(DriverLabel::of::<T>())
.label_discard_if_duplicate(StateCallback::Exit.into_label(s))
}
@ -206,9 +201,8 @@ where
_ => false,
})
})
.system()
.config(|(_, pred)| *pred = Some(Some(s.clone())))
.chain(should_run_adapter::<T>.system())
.chain(should_run_adapter::<T>)
.after(DriverLabel::of::<T>())
.label_discard_if_duplicate(StateCallback::Pause.into_label(s))
}
@ -223,9 +217,8 @@ where
_ => false,
})
})
.system()
.config(|(_, pred)| *pred = Some(Some(s.clone())))
.chain(should_run_adapter::<T>.system())
.chain(should_run_adapter::<T>)
.after(DriverLabel::of::<T>())
.label_discard_if_duplicate(StateCallback::Resume.into_label(s))
}
@ -259,8 +252,7 @@ where
/// Important note: this set must be inserted **before** all other state-dependant sets to work
/// properly!
pub fn get_driver() -> SystemSet {
SystemSet::default()
.with_run_criteria(state_cleaner::<T>.system().label(DriverLabel::of::<T>()))
SystemSet::default().with_run_criteria(state_cleaner::<T>.label(DriverLabel::of::<T>()))
}
pub fn new(initial: T) -> Self {
@ -516,81 +508,63 @@ mod test {
stage
.add_system_set(
State::on_enter_set(MyState::S1)
.with_system((|mut r: ResMut<Vec<&'static str>>| r.push("startup")).system()),
.with_system(|mut r: ResMut<Vec<&'static str>>| r.push("startup")),
)
.add_system_set(
State::on_update_set(MyState::S1).with_system(
(|mut r: ResMut<Vec<&'static str>>, mut s: ResMut<State<MyState>>| {
.add_system_set(State::on_update_set(MyState::S1).with_system(
|mut r: ResMut<Vec<&'static str>>, mut s: ResMut<State<MyState>>| {
r.push("update S1");
s.overwrite_replace(MyState::S2).unwrap();
})
.system(),
),
)
},
))
.add_system_set(
State::on_enter_set(MyState::S2)
.with_system((|mut r: ResMut<Vec<&'static str>>| r.push("enter S2")).system()),
.with_system(|mut r: ResMut<Vec<&'static str>>| r.push("enter S2")),
)
.add_system_set(
State::on_update_set(MyState::S2).with_system(
(|mut r: ResMut<Vec<&'static str>>, mut s: ResMut<State<MyState>>| {
.add_system_set(State::on_update_set(MyState::S2).with_system(
|mut r: ResMut<Vec<&'static str>>, mut s: ResMut<State<MyState>>| {
r.push("update S2");
s.overwrite_replace(MyState::S3).unwrap();
})
.system(),
),
)
},
))
.add_system_set(
State::on_exit_set(MyState::S2)
.with_system((|mut r: ResMut<Vec<&'static str>>| r.push("exit S2")).system()),
.with_system(|mut r: ResMut<Vec<&'static str>>| r.push("exit S2")),
)
.add_system_set(
State::on_enter_set(MyState::S3)
.with_system((|mut r: ResMut<Vec<&'static str>>| r.push("enter S3")).system()),
.with_system(|mut r: ResMut<Vec<&'static str>>| r.push("enter S3")),
)
.add_system_set(
State::on_update_set(MyState::S3).with_system(
(|mut r: ResMut<Vec<&'static str>>, mut s: ResMut<State<MyState>>| {
.add_system_set(State::on_update_set(MyState::S3).with_system(
|mut r: ResMut<Vec<&'static str>>, mut s: ResMut<State<MyState>>| {
r.push("update S3");
s.overwrite_push(MyState::S4).unwrap();
})
.system(),
),
)
},
))
.add_system_set(
State::on_pause_set(MyState::S3)
.with_system((|mut r: ResMut<Vec<&'static str>>| r.push("pause S3")).system()),
.with_system(|mut r: ResMut<Vec<&'static str>>| r.push("pause S3")),
)
.add_system_set(
State::on_update_set(MyState::S4).with_system(
(|mut r: ResMut<Vec<&'static str>>, mut s: ResMut<State<MyState>>| {
.add_system_set(State::on_update_set(MyState::S4).with_system(
|mut r: ResMut<Vec<&'static str>>, mut s: ResMut<State<MyState>>| {
r.push("update S4");
s.overwrite_push(MyState::S5).unwrap();
})
.system(),
),
)
.add_system_set(
State::on_inactive_update_set(MyState::S4).with_system(
(|mut r: ResMut<Vec<&'static str>>| r.push("inactive S4"))
.system()
.label("inactive s4"),
),
)
},
))
.add_system_set(State::on_inactive_update_set(MyState::S4).with_system(
(|mut r: ResMut<Vec<&'static str>>| r.push("inactive S4")).label("inactive s4"),
))
.add_system_set(
State::on_update_set(MyState::S5).with_system(
(|mut r: ResMut<Vec<&'static str>>, mut s: ResMut<State<MyState>>| {
r.push("update S5");
s.overwrite_push(MyState::S6).unwrap();
})
.system()
.after("inactive s4"),
),
)
.add_system_set(
State::on_inactive_update_set(MyState::S5).with_system(
(|mut r: ResMut<Vec<&'static str>>| r.push("inactive S5"))
.system()
.label("inactive s5")
.after("inactive s4"),
),
@ -601,17 +575,16 @@ mod test {
r.push("update S6");
s.overwrite_push(MyState::Final).unwrap();
})
.system()
.after("inactive s5"),
),
)
.add_system_set(
State::on_resume_set(MyState::S4)
.with_system((|mut r: ResMut<Vec<&'static str>>| r.push("resume S4")).system()),
.with_system(|mut r: ResMut<Vec<&'static str>>| r.push("resume S4")),
)
.add_system_set(
State::on_exit_set(MyState::S5)
.with_system((|mut r: ResMut<Vec<&'static str>>| r.push("exit S4")).system()),
.with_system(|mut r: ResMut<Vec<&'static str>>| r.push("exit S4")),
);
const EXPECTED: &[&str] = &[
@ -671,7 +644,7 @@ mod test {
world.insert_resource(State::new(AppState::Main));
world.insert_resource(false);
world.insert_resource("control");
let mut stage = SystemStage::parallel().with_system(should_run_once.system());
let mut stage = SystemStage::parallel().with_system(should_run_once);
stage.run(&mut world);
assert!(*world.get_resource::<bool>().unwrap(), "after control");
@ -679,7 +652,7 @@ mod test {
world.insert_resource("test");
let mut stage = SystemStage::parallel()
.with_system_set(State::<AppState>::get_driver())
.with_system(should_run_once.system());
.with_system(should_run_once);
stage.run(&mut world);
assert!(*world.get_resource::<bool>().unwrap(), "after test");
}

4
crates/bevy_ecs/src/schedule/system_descriptor.rs
View file

@ -30,8 +30,8 @@ use crate::{
/// struct Something;
///
/// SystemStage::parallel()
/// .with_system(do_something.system().label(Something))
/// .with_system(do_the_other_thing.system().after(Something))
/// .with_system(do_something.label(Something))
/// .with_system(do_the_other_thing.after(Something))
/// .with_system(do_something_else.exclusive_system().at_end());
/// ```
pub enum SystemDescriptor {

6
crates/bevy_ecs/src/system/exclusive_system.rs
View file

@ -128,7 +128,7 @@ mod tests {
entity::Entity,
query::With,
schedule::{Stage, SystemStage},
system::{Commands, IntoExclusiveSystem, IntoSystem, Query, ResMut},
system::{Commands, IntoExclusiveSystem, Query, ResMut},
world::World,
};
#[test]
@ -146,7 +146,7 @@ mod tests {
}
}
let mut stage = SystemStage::parallel().with_system(removal.system());
let mut stage = SystemStage::parallel().with_system(removal);
world.spawn().insert(0.0f32);
world.insert_resource(0usize);
stage.run(&mut world);
@ -176,7 +176,7 @@ mod tests {
let mut world = World::new();
world.insert_resource(Vec::<usize>::new());
let mut stage = SystemStage::parallel()
.with_system(spawn_entity.system())
.with_system(spawn_entity)
.with_system(count_entities.exclusive_system());
stage.run(&mut world);
stage.run(&mut world);

2
crates/bevy_ecs/src/system/function_system.rs
View file

@ -251,7 +251,7 @@ impl<In, Out, Param: SystemParam, Marker, F> FunctionSystem<In, Out, Param, Mark
/// fn local_is_42(local: Local<usize>) {
/// assert_eq!(*local, 42);
/// }
/// let mut system = local_is_42.system().config(|config| config.0 = Some(42));
/// let mut system = local_is_42.config(|config| config.0 = Some(42));
/// system.initialize(world);
/// system.run((), world);
/// ```

50
crates/bevy_ecs/src/system/mod.rs
View file

@ -60,7 +60,7 @@ mod tests {
system.run((), &mut world);
}
fn run_system<S: System<In = (), Out = ()>>(world: &mut World, system: S) {
fn run_system<Param, S: IntoSystem<(), (), Param>>(world: &mut World, system: S) {
let mut schedule = Schedule::default();
let mut update = SystemStage::parallel();
update.add_system(system);
@ -121,7 +121,7 @@ mod tests {
world.spawn().insert_bundle((A, C));
world.spawn().insert_bundle((A, D));
run_system(&mut world, query_system.system());
run_system(&mut world, query_system);
assert!(*world.get_resource::<bool>().unwrap(), "system ran");
}
@ -149,7 +149,7 @@ mod tests {
world.insert_resource(false);
world.spawn().insert_bundle((A, B));
run_system(&mut world, query_system.system());
run_system(&mut world, query_system);
assert!(*world.get_resource::<bool>().unwrap(), "system ran");
}
@ -179,7 +179,7 @@ mod tests {
let mut schedule = Schedule::default();
let mut update = SystemStage::parallel();
update.add_system(incr_e_on_flip.system());
update.add_system(incr_e_on_flip);
schedule.add_stage("update", update);
schedule.add_stage(
"clear_trackers",
@ -206,7 +206,7 @@ mod tests {
fn sys(_q1: Query<&mut A>, _q2: Query<&mut A>) {}
let mut world = World::default();
run_system(&mut world, sys.system());
run_system(&mut world, sys);
}
#[test]
@ -214,7 +214,7 @@ mod tests {
fn sys(_q1: Query<&mut A, With<B>>, _q2: Query<&mut A, Without<B>>) {}
let mut world = World::default();
run_system(&mut world, sys.system());
run_system(&mut world, sys);
}
#[test]
@ -222,7 +222,7 @@ mod tests {
fn sys(_q1: Query<(&mut A, &B)>, _q2: Query<&mut A, Without<B>>) {}
let mut world = World::default();
run_system(&mut world, sys.system());
run_system(&mut world, sys);
}
#[test]
@ -231,14 +231,14 @@ mod tests {
fn sys(_q1: Query<&A>, _q2: Query<&mut A>) {}
let mut world = World::default();
run_system(&mut world, sys.system());
run_system(&mut world, sys);
}
#[test]
fn query_set_system() {
fn sys(mut _set: QuerySet<(Query<&mut A>, Query<&A>)>) {}
let mut world = World::default();
run_system(&mut world, sys.system());
run_system(&mut world, sys);
}
#[test]
@ -247,7 +247,7 @@ mod tests {
fn sys(_query: Query<&mut A>, _set: QuerySet<(Query<&mut A>, Query<&B>)>) {}
let mut world = World::default();
run_system(&mut world, sys.system());
run_system(&mut world, sys);
}
#[test]
@ -256,7 +256,7 @@ mod tests {
fn sys(_set_1: QuerySet<(Query<&mut A>,)>, _set_2: QuerySet<(Query<&mut A>, Query<&B>)>) {}
let mut world = World::default();
run_system(&mut world, sys.system());
run_system(&mut world, sys);
}
#[derive(Default)]
@ -264,39 +264,39 @@ mod tests {
_buffer: Vec<u8>,
}
fn test_for_conflicting_resources<S: System<In = (), Out = ()>>(sys: S) {
fn test_for_conflicting_resources<Param, S: IntoSystem<(), (), Param>>(sys: S) {
let mut world = World::default();
world.insert_resource(BufferRes::default());
world.insert_resource(A);
world.insert_resource(B);
run_system(&mut world, sys.system());
run_system(&mut world, sys);
}
#[test]
#[should_panic]
fn conflicting_system_resources() {
fn sys(_: ResMut<BufferRes>, _: Res<BufferRes>) {}
test_for_conflicting_resources(sys.system())
test_for_conflicting_resources(sys)
}
#[test]
#[should_panic]
fn conflicting_system_resources_reverse_order() {
fn sys(_: Res<BufferRes>, _: ResMut<BufferRes>) {}
test_for_conflicting_resources(sys.system())
test_for_conflicting_resources(sys)
}
#[test]
#[should_panic]
fn conflicting_system_resources_multiple_mutable() {
fn sys(_: ResMut<BufferRes>, _: ResMut<BufferRes>) {}
test_for_conflicting_resources(sys.system())
test_for_conflicting_resources(sys)
}
#[test]
fn nonconflicting_system_resources() {
fn sys(_: Local<BufferRes>, _: ResMut<BufferRes>, _: Local<A>, _: ResMut<A>) {}
test_for_conflicting_resources(sys.system())
test_for_conflicting_resources(sys)
}
#[test]
@ -321,7 +321,7 @@ mod tests {
*modified = true;
}
run_system(&mut world, sys.system());
run_system(&mut world, sys);
// ensure the system actually ran
assert!(*world.get_resource::<bool>().unwrap());
@ -352,7 +352,7 @@ mod tests {
*ran = true;
}
run_system(&mut world, validate_removed.system());
run_system(&mut world, validate_removed);
assert!(*world.get_resource::<bool>().unwrap(), "system ran");
}
@ -365,18 +365,10 @@ mod tests {
*modified = true;
}
run_system(
&mut world,
sys.system().config(|config| config.0 = Some(42)),
);
run_system(&mut world, sys.config(|config| config.0 = Some(42)));
// ensure the system actually ran
assert!(*world.get_resource::<bool>().unwrap());
// Now do the same with omitted `.system()`.
world.insert_resource(false);
run_system(&mut world, sys.config(|config| config.0 = Some(42)));
assert!(*world.get_resource::<bool>().unwrap());
}
#[test]
@ -417,7 +409,7 @@ mod tests {
*modified = true;
}
run_system(&mut world, sys.system());
run_system(&mut world, sys);
// ensure the system actually ran
assert!(*world.get_resource::<bool>().unwrap());

2
crates/bevy_ecs/src/system/system.rs
View file

@ -24,7 +24,7 @@ impl SystemId {
///
/// Systems are functions with all arguments implementing [SystemParam](crate::system::SystemParam).
///
/// Systems are added to an application using `App::add_system(my_system.system())`
/// Systems are added to an application using `App::add_system(my_system)`
/// or similar methods, and will generally run once per pass of the main loop.
///
/// Systems are executed in parallel, in opportunistic order; data access is managed automatically.

13
crates/bevy_input/src/lib.rs
View file

@ -7,10 +7,7 @@ pub mod system;
pub mod touch;
pub use axis::*;
use bevy_ecs::{
schedule::{ParallelSystemDescriptorCoercion, SystemLabel},
system::IntoSystem,
};
use bevy_ecs::schedule::{ParallelSystemDescriptorCoercion, SystemLabel};
pub use input::*;
pub mod prelude {
@ -52,7 +49,7 @@ impl Plugin for InputPlugin {
.init_resource::<Input<KeyCode>>()
.add_system_to_stage(
CoreStage::PreUpdate,
keyboard_input_system.system().label(InputSystem),
keyboard_input_system.label(InputSystem),
)
// mouse
.add_event::<MouseButtonInput>()
@ -61,7 +58,7 @@ impl Plugin for InputPlugin {
.init_resource::<Input<MouseButton>>()
.add_system_to_stage(
CoreStage::PreUpdate,
mouse_button_input_system.system().label(InputSystem),
mouse_button_input_system.label(InputSystem),
)
// gamepad
.add_event::<GamepadEvent>()
@ -72,14 +69,14 @@ impl Plugin for InputPlugin {
.init_resource::<Axis<GamepadButton>>()
.add_system_to_stage(
CoreStage::PreUpdate,
gamepad_event_system.system().label(InputSystem),
gamepad_event_system.label(InputSystem),
)
// touch
.add_event::<TouchInput>()
.init_resource::<Touches>()
.add_system_to_stage(
CoreStage::PreUpdate,
touch_screen_input_system.system().label(InputSystem),
touch_screen_input_system.label(InputSystem),
);
}
}

3
crates/bevy_pbr/src/lib.rs
View file

@ -19,7 +19,6 @@ pub mod prelude {
use bevy_app::prelude::*;
use bevy_asset::{AddAsset, Assets, Handle};
use bevy_ecs::system::IntoSystem;
use bevy_render::{prelude::Color, shader};
use material::StandardMaterial;
use render_graph::add_pbr_graph;
@ -34,7 +33,7 @@ impl Plugin for PbrPlugin {
.register_type::<PointLight>()
.add_system_to_stage(
CoreStage::PostUpdate,
shader::asset_shader_defs_system::<StandardMaterial>.system(),
shader::asset_shader_defs_system::<StandardMaterial>,
)
.init_resource::<AmbientLight>();
add_pbr_graph(&mut app.world);

4
crates/bevy_pbr/src/render_graph/lights_node.rs
View file

@ -6,7 +6,7 @@ use crate::{
};
use bevy_core::{bytes_of, Pod, Zeroable};
use bevy_ecs::{
system::{BoxedSystem, IntoSystem, Local, Query, Res, ResMut},
system::{BoxedSystem, ConfigurableSystem, Local, Query, Res, ResMut},
world::World,
};
use bevy_render::{
@ -59,7 +59,7 @@ struct LightCount {
impl SystemNode for LightsNode {
fn get_system(&self) -> BoxedSystem {
let system = lights_node_system.system().config(|config| {
let system = lights_node_system.config(|config| {
config.0 = Some(LightsNodeSystemState {
command_queue: self.command_queue.clone(),
max_point_lights: self.max_point_lights,

42
crates/bevy_render/src/lib.rs
View file

@ -14,7 +14,7 @@ pub mod wireframe;
use bevy_ecs::{
schedule::{ParallelSystemDescriptorCoercion, SystemStage},
system::{IntoExclusiveSystem, IntoSystem, Res},
system::{IntoExclusiveSystem, Res},
};
use bevy_transform::TransformSystem;
use bevy_utils::tracing::warn;
@ -174,58 +174,38 @@ impl Plugin for RenderPlugin {
.init_resource::<RenderResourceBindings>()
.init_resource::<AssetRenderResourceBindings>()
.init_resource::<ActiveCameras>()
.add_startup_system_to_stage(
StartupStage::PreStartup,
check_for_render_resource_context.system(),
)
.add_system_to_stage(CoreStage::PreUpdate, draw::clear_draw_system.system())
.add_startup_system_to_stage(StartupStage::PreStartup, check_for_render_resource_context)
.add_system_to_stage(CoreStage::PreUpdate, draw::clear_draw_system)
.add_system_to_stage(CoreStage::PostUpdate, camera::active_cameras_system)
.add_system_to_stage(
CoreStage::PostUpdate,
camera::active_cameras_system.system(),
camera::camera_system::<OrthographicProjection>.before(RenderSystem::VisibleEntities),
)
.add_system_to_stage(
CoreStage::PostUpdate,
camera::camera_system::<OrthographicProjection>
.system()
.before(RenderSystem::VisibleEntities),
)
.add_system_to_stage(
CoreStage::PostUpdate,
camera::camera_system::<PerspectiveProjection>
.system()
.before(RenderSystem::VisibleEntities),
camera::camera_system::<PerspectiveProjection>.before(RenderSystem::VisibleEntities),
)
.add_system_to_stage(
CoreStage::PostUpdate,
camera::visible_entities_system
.system()
.label(RenderSystem::VisibleEntities)
.after(TransformSystem::TransformPropagate),
)
.add_system_to_stage(RenderStage::RenderResource, shader::shader_update_system)
.add_system_to_stage(
RenderStage::RenderResource,
shader::shader_update_system.system(),
mesh::mesh_resource_provider_system,
)
.add_system_to_stage(
RenderStage::RenderResource,
mesh::mesh_resource_provider_system.system(),
)
.add_system_to_stage(
RenderStage::RenderResource,
Texture::texture_resource_system.system(),
Texture::texture_resource_system,
)
.add_system_to_stage(
RenderStage::RenderGraphSystems,
render_graph::render_graph_schedule_executor_system.exclusive_system(),
)
.add_system_to_stage(
RenderStage::Draw,
pipeline::draw_render_pipelines_system.system(),
)
.add_system_to_stage(
RenderStage::PostRender,
shader::clear_shader_defs_system.system(),
);
.add_system_to_stage(RenderStage::Draw, pipeline::draw_render_pipelines_system)
.add_system_to_stage(RenderStage::PostRender, shader::clear_shader_defs_system);
if let Some(ref config) = self.base_render_graph_config {
crate::base::add_base_graph(config, &mut app.world);

4
crates/bevy_render/src/render_graph/nodes/camera_node.rs
View file

@ -8,7 +8,7 @@ use crate::{
};
use bevy_core::bytes_of;
use bevy_ecs::{
system::{BoxedSystem, IntoSystem, Local, Query, Res, ResMut},
system::{BoxedSystem, ConfigurableSystem, Local, Query, Res, ResMut},
world::World,
};
use bevy_transform::prelude::*;
@ -46,7 +46,7 @@ impl Node for CameraNode {
impl SystemNode for CameraNode {
fn get_system(&self) -> BoxedSystem {
let system = camera_node_system.system().config(|config| {
let system = camera_node_system.config(|config| {
config.0 = Some(CameraNodeState {
camera_name: self.camera_name.clone(),
command_queue: self.command_queue.clone(),

10
crates/bevy_render/src/render_graph/nodes/render_resources_node.rs
View file

@ -14,7 +14,9 @@ use bevy_asset::{Asset, AssetEvent, Assets, Handle, HandleId};
use bevy_ecs::{
entity::Entity,
query::{Changed, Or, With},
system::{BoxedSystem, IntoSystem, Local, Query, QuerySet, RemovedComponents, Res, ResMut},
system::{
BoxedSystem, ConfigurableSystem, Local, Query, QuerySet, RemovedComponents, Res, ResMut,
},
world::World,
};
use bevy_utils::HashMap;
@ -400,7 +402,7 @@ where
T: renderer::RenderResources,
{
fn get_system(&self) -> BoxedSystem {
let system = render_resources_node_system::<T>.system().config(|config| {
let system = render_resources_node_system::<T>.config(|config| {
config.0 = Some(RenderResourcesNodeState {
command_queue: self.command_queue.clone(),
uniform_buffer_arrays: UniformBufferArrays::<Entity, T>::default(),
@ -583,9 +585,7 @@ where
T: renderer::RenderResources + Asset,
{
fn get_system(&self) -> BoxedSystem {
let system = asset_render_resources_node_system::<T>
.system()
.config(|config| {
let system = asset_render_resources_node_system::<T>.config(|config| {
config.0 = Some(RenderResourcesNodeState {
command_queue: self.command_queue.clone(),
uniform_buffer_arrays: UniformBufferArrays::<HandleId, T>::default(),

4
crates/bevy_render/src/wireframe/mod.rs
View file

@ -10,7 +10,7 @@ use bevy_asset::{Assets, Handle, HandleUntyped};
use bevy_ecs::{
query::With,
reflect::ReflectComponent,
system::{IntoSystem, Query, QuerySet, Res},
system::{Query, QuerySet, Res},
world::Mut,
};
use bevy_reflect::{Reflect, TypeUuid};
@ -27,7 +27,7 @@ pub struct WireframePlugin;
impl Plugin for WireframePlugin {
fn build(&self, app: &mut App) {
app.init_resource::<WireframeConfig>()
.add_system_to_stage(crate::RenderStage::Draw, draw_wireframes_system.system());
.add_system_to_stage(crate::RenderStage::Draw, draw_wireframes_system);
let world = app.world.cell();
let mut shaders = world.get_resource_mut::<Assets<Shader>>().unwrap();
let mut pipelines = world

18
crates/bevy_sprite/src/lib.rs
View file

@ -28,10 +28,7 @@ pub use texture_atlas_builder::*;
use bevy_app::prelude::*;
use bevy_asset::{AddAsset, Assets, Handle, HandleUntyped};
use bevy_ecs::{
component::{ComponentDescriptor, StorageType},
system::IntoSystem,
};
use bevy_ecs::component::{ComponentDescriptor, StorageType};
use bevy_math::Vec2;
use bevy_reflect::TypeUuid;
use bevy_render::{
@ -72,14 +69,11 @@ impl Plugin for SpritePlugin {
.add_asset::<TextureAtlas>()
.register_type::<Sprite>()
.register_type::<SpriteResizeMode>()
.add_system_to_stage(CoreStage::PostUpdate, sprite_system.system())
.add_system_to_stage(CoreStage::PostUpdate, sprite_system)
.add_system_to_stage(CoreStage::PostUpdate, material_texture_detection_system)
.add_system_to_stage(
CoreStage::PostUpdate,
material_texture_detection_system.system(),
)
.add_system_to_stage(
CoreStage::PostUpdate,
asset_shader_defs_system::<ColorMaterial>.system(),
asset_shader_defs_system::<ColorMaterial>,
);
let sprite_settings = app
@ -89,11 +83,11 @@ impl Plugin for SpritePlugin {
if sprite_settings.frustum_culling_enabled {
app.add_system_to_stage(
CoreStage::PostUpdate,
frustum_culling::sprite_frustum_culling_system.system(),
frustum_culling::sprite_frustum_culling_system,
)
.add_system_to_stage(
CoreStage::PostUpdate,
frustum_culling::atlas_frustum_culling_system.system(),
frustum_culling::atlas_frustum_culling_system,
);
}
app.world

6
crates/bevy_text/src/lib.rs
View file

@ -29,7 +29,7 @@ pub mod prelude {
use bevy_app::prelude::*;
use bevy_asset::AddAsset;
use bevy_ecs::{entity::Entity, system::IntoSystem};
use bevy_ecs::entity::Entity;
use bevy_render::RenderStage;
pub type DefaultTextPipeline = TextPipeline<Entity>;
@ -43,7 +43,7 @@ impl Plugin for TextPlugin {
.add_asset::<FontAtlasSet>()
.init_asset_loader::<FontLoader>()
.insert_resource(DefaultTextPipeline::default())
.add_system_to_stage(CoreStage::PostUpdate, text2d_system.system())
.add_system_to_stage(RenderStage::Draw, text2d::draw_text2d_system.system());
.add_system_to_stage(CoreStage::PostUpdate, text2d_system)
.add_system_to_stage(RenderStage::Draw, text2d::draw_text2d_system);
}
}

6
crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs
View file

@ -75,7 +75,7 @@ pub fn parent_update_system(
mod test {
use bevy_ecs::{
schedule::{Schedule, Stage, SystemStage},
system::{CommandQueue, IntoSystem},
system::CommandQueue,
world::World,
};
@ -87,8 +87,8 @@ mod test {
let mut world = World::default();
let mut update_stage = SystemStage::parallel();
update_stage.add_system(parent_update_system.system());
update_stage.add_system(transform_propagate_system.system());
update_stage.add_system(parent_update_system);
update_stage.add_system(transform_propagate_system);
let mut schedule = Schedule::default();
schedule.add_stage("update", update_stage);

15
crates/bevy_transform/src/lib.rs
View file

@ -8,10 +8,7 @@ pub mod prelude {
}
use bevy_app::prelude::*;
use bevy_ecs::{
schedule::{ParallelSystemDescriptorCoercion, SystemLabel},
system::IntoSystem,
};
use bevy_ecs::schedule::{ParallelSystemDescriptorCoercion, SystemLabel};
use prelude::{parent_update_system, Children, GlobalTransform, Parent, PreviousParent, Transform};
#[derive(Default)]
@ -33,27 +30,21 @@ impl Plugin for TransformPlugin {
// add transform systems to startup so the first update is "correct"
.add_startup_system_to_stage(
StartupStage::PostStartup,
parent_update_system
.system()
.label(TransformSystem::ParentUpdate),
parent_update_system.label(TransformSystem::ParentUpdate),
)
.add_startup_system_to_stage(
StartupStage::PostStartup,
transform_propagate_system::transform_propagate_system
.system()
.label(TransformSystem::TransformPropagate)
.after(TransformSystem::ParentUpdate),
)
.add_system_to_stage(
CoreStage::PostUpdate,
parent_update_system
.system()
.label(TransformSystem::ParentUpdate),
parent_update_system.label(TransformSystem::ParentUpdate),
)
.add_system_to_stage(
CoreStage::PostUpdate,
transform_propagate_system::transform_propagate_system
.system()
.label(TransformSystem::TransformPropagate)
.after(TransformSystem::ParentUpdate),
);

10
crates/bevy_transform/src/transform_propagate_system.rs
View file

@ -77,7 +77,7 @@ fn propagate_recursive(
mod test {
use bevy_ecs::{
schedule::{Schedule, Stage, SystemStage},
system::{CommandQueue, Commands, IntoSystem},
system::{CommandQueue, Commands},
world::World,
};
@ -89,8 +89,8 @@ mod test {
let mut world = World::default();
let mut update_stage = SystemStage::parallel();
update_stage.add_system(parent_update_system.system());
update_stage.add_system(transform_propagate_system.system());
update_stage.add_system(parent_update_system);
update_stage.add_system(transform_propagate_system);
let mut schedule = Schedule::default();
schedule.add_stage("update", update_stage);
@ -144,8 +144,8 @@ mod test {
let mut world = World::default();
let mut update_stage = SystemStage::parallel();
update_stage.add_system(parent_update_system.system());
update_stage.add_system(transform_propagate_system.system());
update_stage.add_system(parent_update_system);
update_stage.add_system(transform_propagate_system);
let mut schedule = Schedule::default();
schedule.add_stage("update", update_stage);

18
crates/bevy_ui/src/lib.rs
View file

@ -22,10 +22,7 @@ pub mod prelude {
}
use bevy_app::prelude::*;
use bevy_ecs::{
schedule::{ParallelSystemDescriptorCoercion, SystemLabel},
system::IntoSystem,
};
use bevy_ecs::schedule::{ParallelSystemDescriptorCoercion, SystemLabel};
use bevy_input::InputSystem;
use bevy_math::{Rect, Size};
use bevy_render::RenderStage;
@ -62,35 +59,30 @@ impl Plugin for UiPlugin {
.register_type::<Val>()
.add_system_to_stage(
CoreStage::PreUpdate,
ui_focus_system
.system()
.label(UiSystem::Focus)
.after(InputSystem),
ui_focus_system.label(UiSystem::Focus).after(InputSystem),
)
// add these stages to front because these must run before transform update systems
.add_system_to_stage(
CoreStage::PostUpdate,
widget::text_system.system().before(UiSystem::Flex),
widget::text_system.before(UiSystem::Flex),
)
.add_system_to_stage(
CoreStage::PostUpdate,
widget::image_node_system.system().before(UiSystem::Flex),
widget::image_node_system.before(UiSystem::Flex),
)
.add_system_to_stage(
CoreStage::PostUpdate,
flex_node_system
.system()
.label(UiSystem::Flex)
.before(TransformSystem::TransformPropagate),
)
.add_system_to_stage(
CoreStage::PostUpdate,
ui_z_system
.system()
.after(UiSystem::Flex)
.before(TransformSystem::TransformPropagate),
)
.add_system_to_stage(RenderStage::Draw, widget::draw_text_system.system());
.add_system_to_stage(RenderStage::Draw, widget::draw_text_system);
crate::render::add_ui_graph(&mut app.world);
}

4
crates/bevy_ui/src/update.rs
View file

@ -54,7 +54,7 @@ fn update_hierarchy(
mod tests {
use bevy_ecs::{
schedule::{Schedule, Stage, SystemStage},
system::{CommandQueue, Commands, IntoSystem},
system::{CommandQueue, Commands},
world::World,
};
use bevy_transform::{components::Transform, hierarchy::BuildChildren};
@ -122,7 +122,7 @@ mod tests {
let mut schedule = Schedule::default();
let mut update_stage = SystemStage::parallel();
update_stage.add_system(ui_z_system.system());
update_stage.add_system(ui_z_system);
schedule.add_stage("update", update_stage);
schedule.run(&mut world);

6
crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
View file

@ -1,7 +1,7 @@
use crate::renderer::WgpuRenderResourceContext;
use bevy_app::prelude::*;
use bevy_diagnostic::{Diagnostic, DiagnosticId, Diagnostics};
use bevy_ecs::system::{IntoSystem, Res, ResMut};
use bevy_ecs::system::{Res, ResMut};
use bevy_render::renderer::RenderResourceContext;
#[derive(Default)]
@ -9,8 +9,8 @@ pub struct WgpuResourceDiagnosticsPlugin;
impl Plugin for WgpuResourceDiagnosticsPlugin {
fn build(&self, app: &mut App) {
app.add_startup_system(Self::setup_system.system())
.add_system(Self::diagnostic_system.system());
app.add_startup_system(Self::setup_system)
.add_system(Self::diagnostic_system);
}
}

10
crates/bevy_wgpu/src/lib.rs
View file

@ -10,10 +10,7 @@ pub use wgpu_renderer::*;
pub use wgpu_resources::*;
use bevy_app::prelude::*;
use bevy_ecs::{
system::{IntoExclusiveSystem, IntoSystem},
world::World,
};
use bevy_ecs::{system::IntoExclusiveSystem, world::World};
use bevy_render::{
renderer::{shared_buffers_update_system, RenderResourceContext, SharedBuffers},
RenderStage,
@ -107,10 +104,7 @@ impl Plugin for WgpuPlugin {
fn build(&self, app: &mut App) {
let render_system = get_wgpu_render_system(&mut app.world);
app.add_system_to_stage(RenderStage::Render, render_system.exclusive_system())
.add_system_to_stage(
RenderStage::PostRender,
shared_buffers_update_system.system(),
);
.add_system_to_stage(RenderStage::PostRender, shared_buffers_update_system);
}
}

3
crates/bevy_window/src/lib.rs
View file

@ -3,7 +3,6 @@ mod system;
mod window;
mod windows;
use bevy_ecs::system::IntoSystem;
pub use event::*;
pub use system::*;
pub use window::*;
@ -68,7 +67,7 @@ impl Plugin for WindowPlugin {
}
if self.exit_on_close {
app.add_system(exit_on_window_close_system.system());
app.add_system(exit_on_window_close_system);
}
}
}

4
examples/2d/many_sprites.rs
View file

@ -24,8 +24,8 @@ fn main() {
})
.add_plugins(DefaultPlugins)
.add_startup_system(setup)
.add_system(tick.system().label("Tick"))
.add_system(move_camera.system().after("Tick"))
.add_system(tick.label("Tick"))
.add_system(move_camera.after("Tick"))
.run()
}

2
examples/3d/3d_scene.rs
View file

@ -4,7 +4,7 @@ fn main() {
App::new()
.insert_resource(Msaa { samples: 4 })
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_startup_system(setup)
.run();
}

4
examples/3d/load_gltf.rs
View file

@ -8,8 +8,8 @@ fn main() {
})
.insert_resource(Msaa { samples: 4 })
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_system(rotator_system.system())
.add_startup_system(setup)
.add_system(rotator_system)
.run();
}

2
examples/3d/msaa.rs
View file

@ -8,7 +8,7 @@ fn main() {
App::new()
.insert_resource(Msaa { samples: 4 })
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_startup_system(setup)
.run();
}

2
examples/3d/orthographic.rs
View file

@ -4,7 +4,7 @@ fn main() {
App::new()
.insert_resource(Msaa { samples: 4 })
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_startup_system(setup)
.run();
}

4
examples/3d/parenting.rs
View file

@ -6,8 +6,8 @@ fn main() {
App::new()
.insert_resource(Msaa { samples: 4 })
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_system(rotator_system.system())
.add_startup_system(setup)
.add_system(rotator_system)
.run();
}

2
examples/3d/pbr.rs
View file

@ -5,7 +5,7 @@ fn main() {
App::new()
.insert_resource(Msaa { samples: 4 })
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_startup_system(setup)
.run();
}

6
examples/3d/render_to_texture.rs
View file

@ -226,8 +226,8 @@ fn setup(
fn main() {
let mut app = App::new();
app.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_system(cube_rotator_system.system())
.add_system(rotator_system.system())
.add_startup_system(setup)
.add_system(cube_rotator_system)
.add_system(rotator_system)
.run();
}

4
examples/3d/spawner.rs
View file

@ -17,8 +17,8 @@ fn main() {
.add_plugins(DefaultPlugins)
.add_plugin(FrameTimeDiagnosticsPlugin::default())
.add_plugin(LogDiagnosticsPlugin::default())
.add_startup_system(setup.system())
.add_system(move_cubes.system())
.add_startup_system(setup)
.add_system(move_cubes)
.run();
}

2
examples/3d/texture.rs
View file

@ -4,7 +4,7 @@ use bevy::prelude::*;
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_startup_system(setup)
.run();
}

6
examples/3d/update_gltf_scene.rs
View file

@ -5,9 +5,9 @@ fn main() {
.insert_resource(Msaa { samples: 4 })
.add_plugins(DefaultPlugins)
.insert_resource(SceneInstance::default())
.add_startup_system(setup.system())
.add_system(scene_update.system())
.add_system(move_scene_entities.system())
.add_startup_system(setup)
.add_system(scene_update)
.add_system(move_scene_entities)
.run();
}

2
examples/3d/wireframe.rs
View file

@ -16,7 +16,7 @@ fn main() {
})
.add_plugins(DefaultPlugins)
.add_plugin(WireframePlugin)
.add_startup_system(setup.system())
.add_startup_system(setup)
.run();
}

6
examples/3d/z_sort_debug.rs
View file

@ -11,9 +11,9 @@ use bevy::{
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_system(rotator_system.system())
.add_system(camera_order_color_system.system())
.add_startup_system(setup)
.add_system(rotator_system)
.add_system(camera_order_color_system)
.run();
}

2
examples/android/android.rs
View file

@ -6,7 +6,7 @@ fn main() {
App::new()
.insert_resource(Msaa { samples: 2 })
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_startup_system(setup)
.run();
}

2
examples/app/custom_loop.rs
View file

@ -24,6 +24,6 @@ fn main() {
App::new()
.insert_resource(Input(String::new()))
.set_runner(my_runner)
.add_system(print_system.system())
.add_system(print_system)
.run();
}

2
examples/app/drag_and_drop.rs
View file

@ -3,7 +3,7 @@ use bevy::prelude::*;
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_system(file_drag_and_drop_system.system())
.add_system(file_drag_and_drop_system)
.run();
}

4
examples/app/headless.rs
View file

@ -13,7 +13,7 @@ fn main() {
App::new()
.insert_resource(ScheduleRunnerSettings::run_once())
.add_plugins(MinimalPlugins)
.add_system(hello_world_system.system())
.add_system(hello_world_system)
.run();
// this app loops forever at 60 fps
@ -22,7 +22,7 @@ fn main() {
1.0 / 60.0,
)))
.add_plugins(MinimalPlugins)
.add_system(counter.system())
.add_system(counter)
.run();
}

2
examples/app/logs.rs
View file

@ -9,7 +9,7 @@ fn main() {
// filter: "wgpu=warn,bevy_ecs=info".to_string(),
// })
.add_plugins(DefaultPlugins)
.add_system(log_system.system())
.add_system(log_system)
.run();
}

3
examples/app/plugin.rs
View file

@ -28,8 +28,7 @@ impl Plugin for PrintMessagePlugin {
message: self.message.clone(),
timer: Timer::new(self.wait_duration, true),
};
app.insert_resource(state)
.add_system(print_message_system.system());
app.insert_resource(state).add_system(print_message_system);
}
}

4
examples/app/plugin_group.rs
View file

@ -29,7 +29,7 @@ pub struct PrintHelloPlugin;
impl Plugin for PrintHelloPlugin {
fn build(&self, app: &mut App) {
app.add_system(print_hello_system.system());
app.add_system(print_hello_system);
}
}
@ -41,7 +41,7 @@ pub struct PrintWorldPlugin;
impl Plugin for PrintWorldPlugin {
fn build(&self, app: &mut App) {
app.add_system(print_world_system.system());
app.add_system(print_world_system);
}
}

4
examples/app/return_after_run.rs
View file

@ -8,7 +8,7 @@ fn main() {
})
.insert_resource(ClearColor(Color::rgb(0.2, 0.2, 0.8)))
.add_plugins(DefaultPlugins)
.add_system(system1.system())
.add_system(system1)
.run();
println!("Running another App.");
App::new()
@ -19,7 +19,7 @@ fn main() {
.add_plugins_with(DefaultPlugins, |group| {
group.disable::<bevy::log::LogPlugin>()
})
.add_system(system2.system())
.add_system(system2)
.run();
println!("Done.");
}

2
examples/asset/asset_loading.rs
View file

@ -5,7 +5,7 @@ fn main() {
App::new()
.insert_resource(Msaa { samples: 4 })
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_startup_system(setup)
.run();
}

4
examples/asset/custom_asset.rs
View file

@ -39,8 +39,8 @@ fn main() {
.init_resource::<State>()
.add_asset::<CustomAsset>()
.init_asset_loader::<CustomAssetLoader>()
.add_startup_system(setup.system())
.add_system(print_on_load.system())
.add_startup_system(setup)
.add_system(print_on_load)
.run();
}

2
examples/asset/custom_asset_io.rs
View file

@ -85,7 +85,7 @@ fn main() {
// asset system are initialized correctly.
group.add_before::<bevy::asset::AssetPlugin, _>(CustomAssetIoPlugin)
})
.add_startup_system(setup.system())
.add_startup_system(setup)
.run();
}

2
examples/asset/hot_asset_reloading.rs
View file

@ -6,7 +6,7 @@ use bevy::prelude::*;
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_startup_system(setup)
.run();
}

8
examples/async_tasks/async_compute.rs
View file

@ -12,10 +12,10 @@ fn main() {
App::new()
.insert_resource(Msaa { samples: 4 })
.add_plugins(DefaultPlugins)
.add_startup_system(setup_env.system())
.add_startup_system(add_assets.system())
.add_startup_system(spawn_tasks.system())
.add_system(handle_tasks.system())
.add_startup_system(setup_env)
.add_startup_system(add_assets)
.add_startup_system(spawn_tasks)
.add_system(handle_tasks)
.run();
}

2
examples/audio/audio.rs
View file

@ -4,7 +4,7 @@ use bevy::prelude::*;
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_startup_system(setup)
.run();
}

4
examples/diagnostics/custom_diagnostic.rs
View file

@ -10,8 +10,8 @@ fn main() {
// The "print diagnostics" plugin is optional. It just visualizes our diagnostics in the
// console
.add_plugin(LogDiagnosticsPlugin::default())
.add_startup_system(setup_diagnostic_system.system())
.add_system(my_system.system())
.add_startup_system(setup_diagnostic_system)
.add_system(my_system)
.run();
}

8
examples/ecs/component_change_detection.rs
View file

@ -5,10 +5,10 @@ use rand::Rng;
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_system(change_component.system())
.add_system(change_detection.system())
.add_system(tracker_monitoring.system())
.add_startup_system(setup)
.add_system(change_component)
.add_system(change_detection)
.add_system(tracker_monitoring)
.run();
}

4
examples/ecs/event.rs
View file

@ -7,8 +7,8 @@ fn main() {
.add_plugins(DefaultPlugins)
.add_event::<MyEvent>()
.init_resource::<EventTriggerState>()
.add_system(event_trigger_system.system())
.add_system(event_listener_system.system())
.add_system(event_trigger_system)
.add_system(event_listener_system)
.run();
}

4
examples/ecs/fixed_timestep.rs
View file

@ -12,7 +12,7 @@ fn main() {
App::new()
.add_plugins(DefaultPlugins)
// this system will run once every update (it should match your screen's refresh rate)
.add_system(frame_update.system())
.add_system(frame_update)
// add a new stage that runs twice a second
.add_stage_after(
CoreStage::Update,
@ -24,7 +24,7 @@ fn main() {
// FixedTimestep state from within a system
.with_label(LABEL),
)
.with_system(fixed_update.system()),
.with_system(fixed_update),
)
.run();
}

4
examples/ecs/hierarchy.rs
View file

@ -3,8 +3,8 @@ use bevy::prelude::*;
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_system(rotate.system())
.add_startup_system(setup)
.add_system(rotate)
.run();
}

6
examples/ecs/iter_combinations.rs
View file

@ -10,14 +10,14 @@ fn main() {
App::new()
.insert_resource(Msaa { samples: 4 })
.add_plugins(DefaultPlugins)
.add_startup_system(generate_bodies.system())
.add_startup_system(generate_bodies)
.add_stage_after(
CoreStage::Update,
FixedUpdateStage,
SystemStage::parallel()
.with_run_criteria(FixedTimestep::step(DELTA_TIME))
.with_system(interact_bodies.system())
.with_system(integrate.system()),
.with_system(interact_bodies)
.with_system(integrate),
)
.run();
}

6
examples/ecs/parallel_query.rs
View file

@ -70,8 +70,8 @@ fn bounce_system(
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_startup_system(spawn_system.system())
.add_system(move_system.system())
.add_system(bounce_system.system())
.add_startup_system(spawn_system)
.add_system(move_system)
.add_system(bounce_system)
.run();
}

6
examples/ecs/query_bundle.rs
View file

@ -3,9 +3,9 @@ use bevy::{log::LogPlugin, prelude::*};
fn main() {
App::new()
.add_plugin(LogPlugin)
.add_startup_system(setup.system())
.add_system(log_names.system().label(LogNamesSystem))
.add_system(log_person_bundles.system().after(LogNamesSystem))
.add_startup_system(setup)
.add_system(log_names.label(LogNamesSystem))
.add_system(log_person_bundles.after(LogNamesSystem))
.run();
}

6
examples/ecs/removal_detection.rs
View file

@ -15,9 +15,9 @@ fn main() {
// `CoreStage::PostUpdate` stage.
App::new()
.add_plugins(DefaultPlugins)
.add_startup_system(setup.system())
.add_system_to_stage(CoreStage::Update, remove_component.system())
.add_system_to_stage(CoreStage::PostUpdate, react_on_removal.system())
.add_startup_system(setup)
.add_system_to_stage(CoreStage::Update, remove_component)
.add_system_to_stage(CoreStage::PostUpdate, react_on_removal)
.run();
}

4
examples/ecs/startup_system.rs
View file

@ -2,8 +2,8 @@ use bevy::prelude::*;
fn main() {
App::new()
.add_startup_system(startup_system.system())
.add_system(normal_system.system())
.add_startup_system(startup_system)
.add_system(normal_system)
.run();
}

12
examples/ecs/state.rs
View file

@ -7,14 +7,14 @@ fn main() {
.add_plugins(DefaultPlugins)
.init_resource::<ButtonMaterials>()
.add_state(AppState::Menu)
.add_system_set(SystemSet::on_enter(AppState::Menu).with_system(setup_menu.system()))
.add_system_set(SystemSet::on_update(AppState::Menu).with_system(menu.system()))
.add_system_set(SystemSet::on_exit(AppState::Menu).with_system(cleanup_menu.system()))
.add_system_set(SystemSet::on_enter(AppState::InGame).with_system(setup_game.system()))
.add_system_set(SystemSet::on_enter(AppState::Menu).with_system(setup_menu))
.add_system_set(SystemSet::on_update(AppState::Menu).with_system(menu))
.add_system_set(SystemSet::on_exit(AppState::Menu).with_system(cleanup_menu))
.add_system_set(SystemSet::on_enter(AppState::InGame).with_system(setup_game))
.add_system_set(
SystemSet::on_update(AppState::InGame)
.with_system(movement.system())
.with_system(change_color.system()),
.with_system(movement)
.with_system(change_color),
)
.run();
}

2
examples/ecs/system_chaining.rs
View file

@ -4,7 +4,7 @@ use bevy::prelude::*;
fn main() {
App::new()
.insert_resource(Message("42".to_string()))
.add_system(parse_message_system.system().chain(handler_system.system()))
.add_system(parse_message_system.chain(handler_system))
.run();
}

4
examples/ecs/system_param.rs
View file

@ -4,8 +4,8 @@ use bevy::{ecs::system::SystemParam, prelude::*};
fn main() {
App::new()
.insert_resource(PlayerCount(0))
.add_startup_system(spawn.system())
.add_system(count_players.system())
.add_startup_system(spawn)
.add_system(count_players)
.run();
}

13
examples/ecs/system_sets.rs
View file

@ -63,16 +63,14 @@ fn main() {
.label(Physics)
// This criteria ensures this whole system set only runs when this system's
// output says so (ShouldRun::Yes)
.with_run_criteria(run_for_a_second.system())
.with_run_criteria(run_for_a_second)
.with_system(
update_velocity
.system()
// Only applied to the `update_velocity` system
.label(PhysicsSystem::UpdateVelocity),
)
.with_system(
movement
.system()
// Only applied to the `movement` system
.label(PhysicsSystem::Movement)
// Enforce order within this system by specifying this
@ -93,14 +91,13 @@ fn main() {
.with_run_criteria(RunCriteria::pipe("is_done_label", inverse.system()))
// `collision` and `sfx` are not ordered with respect to
// each other, and may run in any order
.with_system(collision.system())
.with_system(sfx.system()),
.with_system(collision)
.with_system(sfx),
)
.add_system(
exit.system()
.after(PostPhysics)
exit.after(PostPhysics)
// Label the run criteria such that the `PostPhysics` set can reference it
.with_run_criteria(is_done.system().label("is_done_label")),
.with_run_criteria(is_done.label("is_done_label")),
)
.run();
}

6
examples/ecs/timers.rs
View file

@ -4,9 +4,9 @@ fn main() {
App::new()
.add_plugins(DefaultPlugins)
.insert_resource(Countdown::default())
.add_startup_system(setup_system.system())
.add_system(countdown_system.system())
.add_system(timer_system.system())
.add_startup_system(setup_system)
.add_system(countdown_system)
.add_system(timer_system)
.run();
}

28
examples/game/alien_cake_addict.rs
View file

@ -18,29 +18,25 @@ fn main() {
.init_resource::<Game>()
.add_plugins(DefaultPlugins)
.add_state(GameState::Playing)
.add_startup_system(setup_cameras.system())
.add_system_set(SystemSet::on_enter(GameState::Playing).with_system(setup.system()))
.add_startup_system(setup_cameras)
.add_system_set(SystemSet::on_enter(GameState::Playing).with_system(setup))
.add_system_set(
SystemSet::on_update(GameState::Playing)
.with_system(move_player.system())
.with_system(focus_camera.system())
.with_system(rotate_bonus.system())
.with_system(scoreboard_system.system()),
.with_system(move_player)
.with_system(focus_camera)
.with_system(rotate_bonus)
.with_system(scoreboard_system),
)
.add_system_set(SystemSet::on_exit(GameState::Playing).with_system(teardown.system()))
.add_system_set(
SystemSet::on_enter(GameState::GameOver).with_system(display_score.system()),
)
.add_system_set(
SystemSet::on_update(GameState::GameOver).with_system(gameover_keyboard.system()),
)
.add_system_set(SystemSet::on_exit(GameState::GameOver).with_system(teardown.system()))
.add_system_set(SystemSet::on_exit(GameState::Playing).with_system(teardown))
.add_system_set(SystemSet::on_enter(GameState::GameOver).with_system(display_score))
.add_system_set(SystemSet::on_update(GameState::GameOver).with_system(gameover_keyboard))
.add_system_set(SystemSet::on_exit(GameState::GameOver).with_system(teardown))
.add_system_set(
SystemSet::new()
.with_run_criteria(FixedTimestep::step(5.0))
.with_system(spawn_bonus.system()),
.with_system(spawn_bonus),
)
.add_system(bevy::input::system::exit_on_esc_system.system())
.add_system(bevy::input::system::exit_on_esc_system)
.run();
}

12
examples/game/breakout.rs
View file

@ -12,16 +12,16 @@ fn main() {
.add_plugins(DefaultPlugins)
.insert_resource(Scoreboard { score: 0 })
.insert_resource(ClearColor(Color::rgb(0.9, 0.9, 0.9)))
.add_startup_system(setup.system())
.add_startup_system(setup)
.add_system_set(
SystemSet::new()
.with_run_criteria(FixedTimestep::step(TIME_STEP as f64))
.with_system(paddle_movement_system.system())
.with_system(ball_collision_system.system())
.with_system(ball_movement_system.system()),
.with_system(paddle_movement_system)
.with_system(ball_collision_system)
.with_system(ball_movement_system),
)
.add_system(scoreboard_system.system())
.add_system(bevy::input::system::exit_on_esc_system.system())
.add_system(scoreboard_system)
.add_system(bevy::input::system::exit_on_esc_system)
.run();
}

2
examples/hello_world.rs
View file

@ -1,7 +1,7 @@
use bevy::prelude::*;
fn main() {
App::new().add_system(hello_world_system.system()).run();
App::new().add_system(hello_world_system).run();
}
fn hello_world_system() {

2
examples/input/char_input_events.rs
View file

@ -3,7 +3,7 @@ use bevy::{prelude::*, window::ReceivedCharacter};
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_system(print_char_event_system.system())
.add_system(print_char_event_system)
.run();
}

4
examples/input/gamepad_input.rs
View file

@ -8,8 +8,8 @@ fn main() {
App::new()
.add_plugins(DefaultPlugins)
.init_resource::<GamepadLobby>()
.add_system_to_stage(CoreStage::PreUpdate, connection_system.system())
.add_system(gamepad_system.system())
.add_system_to_stage(CoreStage::PreUpdate, connection_system)
.add_system(gamepad_system)
.run();
}

2
examples/input/gamepad_input_events.rs
View file

@ -6,7 +6,7 @@ use bevy::{
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_system(gamepad_events.system())
.add_system(gamepad_events)
.run();
}

2
examples/input/keyboard_input.rs
View file

@ -6,7 +6,7 @@ use bevy::{
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_system(keyboard_input_system.system())
.add_system(keyboard_input_system)
.run();
}

2
examples/input/keyboard_input_events.rs
View file

@ -3,7 +3,7 @@ use bevy::{input::keyboard::KeyboardInput, prelude::*};
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_system(print_keyboard_event_system.system())
.add_system(print_keyboard_event_system)
.run();
}

2
examples/input/keyboard_modifiers.rs
View file

@ -6,7 +6,7 @@ use bevy::{
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_system(keyboard_input_system.system())
.add_system(keyboard_input_system)
.run();
}

2
examples/input/mouse_input.rs
View file

@ -3,7 +3,7 @@ use bevy::prelude::*;
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_system(mouse_click_system.system())
.add_system(mouse_click_system)
.run();
}

2
examples/input/mouse_input_events.rs
View file

@ -7,7 +7,7 @@ use bevy::{
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_system(print_mouse_events_system.system())
.add_system(print_mouse_events_system)
.run();
}

2
examples/input/touch_input.rs
View file

@ -3,7 +3,7 @@ use bevy::{input::touch::*, prelude::*};
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_system(touch_system.system())
.add_system(touch_system)
.run();
}

2
examples/input/touch_input_events.rs
View file

@ -3,7 +3,7 @@ use bevy::{input::touch::*, prelude::*};
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_system(touch_event_system.system())
.add_system(touch_event_system)
.run();
}

4
examples/ios/src/lib.rs
View file

@ -12,8 +12,8 @@ fn main() {
})
.insert_resource(Msaa { samples: 4 })
.add_plugins(DefaultPlugins)
.add_startup_system(setup_scene.system())
.add_startup_system(setup_music.system())
.add_startup_system(setup_scene)
.add_startup_system(setup_music)
.run();
}
/// set up a simple 3D scene

2
examples/reflection/generic_reflection.rs
View file

@ -6,7 +6,7 @@ fn main() {
App::new()
.add_plugins(DefaultPlugins)
.register_type::<MyType<u32>>()
.add_startup_system(setup.system())
.add_startup_system(setup)
.run();
}

Some files were not shown because too many files have changed in this diff Show more