[Merged by Bors] - Migrate engine to Schedule v3

.github/contributing/example_style_guide.md

@@ -38,7 +38,7 @@ For more advice on writing examples, see the [relevant section](../../CONTRIBUTI
 4. In Queries, prefer `With<T>` filters over actually fetching unused data with `&T`.
 5. Prefer disjoint queries using `With` and `Without` over param sets when you need more than one query in a single system.
 6. Prefer structs with named fields over tuple structs except in the case of single-field wrapper types.
-7. Use enum-labels over string-labels for system / stage / etc. labels.
+7. Use enum-labels over string-labels for system / schedule / etc. labels.
 
 ## "Feature" examples
 

Cargo.toml

@@ -901,7 +901,7 @@ path = "examples/ecs/removal_detection.rs"
 
 [package.metadata.example.removal_detection]
 name = "Removal Detection"
-description = "Query for entities that had a specific component removed in a previous stage during the current frame"
+description = "Query for entities that had a specific component removed earlier in the same current frame"
 category = "ECS (Entity Component System)"
 wasm = false
 

benches/benches/bevy_ecs/components/archetype_updates.rs

@@ -1,22 +1,18 @@
-use bevy_ecs::{
-    component::Component,
-    schedule::{Stage, SystemStage},
-    world::World,
-};
+use bevy_ecs::{component::Component, world::World};
 use criterion::{BenchmarkId, Criterion};
 
 #[derive(Component)]
 struct A<const N: u16>(f32);
 
-fn setup(system_count: usize) -> (World, SystemStage) {
+fn setup(system_count: usize) -> (World, Schedule) {
     let mut world = World::new();
     fn empty() {}
-    let mut stage = SystemStage::parallel();
+    let mut schedule = Schedule::new();
     for _ in 0..system_count {
-        stage.add_system(empty);
+        schedule.add_system(empty);
     }
-    stage.run(&mut world);
-    (world, stage)
+    schedule.run(&mut world);
+    (world, schedule)
 }
 
 /// create `count` entities with distinct archetypes
@@ -78,13 +74,13 @@ pub fn no_archetypes(criterion: &mut Criterion) {
     let mut group = criterion.benchmark_group("no_archetypes");
     for i in 0..=5 {
         let system_count = i * 20;
-        let (mut world, mut stage) = setup(system_count);
+        let (mut world, mut schedule) = setup(system_count);
         group.bench_with_input(
             BenchmarkId::new("system_count", system_count),
             &system_count,
             |bencher, &_system_count| {
                 bencher.iter(|| {
-                    stage.run(&mut world);
+                    schedule.run(&mut world);
                 });
             },
         );
@@ -101,12 +97,12 @@ pub fn added_archetypes(criterion: &mut Criterion) {
             |bencher, &archetype_count| {
                 bencher.iter_batched(
                     || {
-                        let (mut world, stage) = setup(SYSTEM_COUNT);
+                        let (mut world, schedule) = setup(SYSTEM_COUNT);
                         add_archetypes(&mut world, archetype_count);
-                        (world, stage)
+                        (world, schedule)
                     },
-                    |(mut world, mut stage)| {
-                        stage.run(&mut world);
+                    |(mut world, mut schedule)| {
+                        schedule.run(&mut world);
                     },
                     criterion::BatchSize::LargeInput,
                 );

benches/benches/bevy_ecs/empty_archetypes.rs

@@ -1,9 +1,4 @@
-use bevy_ecs::{
-    component::Component,
-    prelude::*,
-    schedule::{Stage, SystemStage},
-    world::World,
-};
+use bevy_ecs::{component::Component, prelude::*, world::World};
 use bevy_tasks::{ComputeTaskPool, TaskPool};
 use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
 
@@ -80,14 +75,14 @@ fn par_for_each(
     });
 }
 
-fn setup(parallel: bool, setup: impl FnOnce(&mut SystemStage)) -> (World, SystemStage) {
+fn setup(parallel: bool, setup: impl FnOnce(&mut Schedule)) -> (World, Schedule) {
     let mut world = World::new();
-    let mut stage = SystemStage::parallel();
+    let mut schedule = Schedule::new();
     if parallel {
         world.insert_resource(ComputeTaskPool(TaskPool::default()));
     }
-    setup(&mut stage);
-    (world, stage)
+    setup(&mut schedule);
+    (world, schedule)
 }
 
 /// create `count` entities with distinct archetypes
@@ -158,8 +153,8 @@ fn add_archetypes(world: &mut World, count: u16) {
 fn empty_archetypes(criterion: &mut Criterion) {
     let mut group = criterion.benchmark_group("empty_archetypes");
     for archetype_count in [10, 100, 500, 1000, 2000, 5000, 10000] {
-        let (mut world, mut stage) = setup(true, |stage| {
-            stage.add_system(iter);
+        let (mut world, mut schedule) = setup(true, |schedule| {
+            schedule.add_system(iter);
         });
         add_archetypes(&mut world, archetype_count);
         world.clear_entities();
@@ -177,20 +172,20 @@ fn empty_archetypes(criterion: &mut Criterion) {
         e.insert(A::<10>(1.0));
         e.insert(A::<11>(1.0));
         e.insert(A::<12>(1.0));
-        stage.run(&mut world);
+        schedule.run(&mut world);
         group.bench_with_input(
             BenchmarkId::new("iter", archetype_count),
             &archetype_count,
             |bencher, &_| {
                 bencher.iter(|| {
-                    stage.run(&mut world);
+                    schedule.run(&mut world);
                 })
             },
         );
     }
     for archetype_count in [10, 100, 500, 1000, 2000, 5000, 10000] {
-        let (mut world, mut stage) = setup(true, |stage| {
-            stage.add_system(for_each);
+        let (mut world, mut schedule) = setup(true, |schedule| {
+            schedule.add_system(for_each);
         });
         add_archetypes(&mut world, archetype_count);
         world.clear_entities();
@@ -208,20 +203,20 @@ fn empty_archetypes(criterion: &mut Criterion) {
         e.insert(A::<10>(1.0));
         e.insert(A::<11>(1.0));
         e.insert(A::<12>(1.0));
-        stage.run(&mut world);
+        schedule.run(&mut world);
         group.bench_with_input(
             BenchmarkId::new("for_each", archetype_count),
             &archetype_count,
             |bencher, &_| {
                 bencher.iter(|| {
-                    stage.run(&mut world);
+                    schedule.run(&mut world);
                 })
             },
         );
     }
     for archetype_count in [10, 100, 500, 1000, 2000, 5000, 10000] {
-        let (mut world, mut stage) = setup(true, |stage| {
-            stage.add_system(par_for_each);
+        let (mut world, mut schedule) = setup(true, |schedule| {
+            schedule.add_system(par_for_each);
         });
         add_archetypes(&mut world, archetype_count);
         world.clear_entities();
@@ -239,13 +234,13 @@ fn empty_archetypes(criterion: &mut Criterion) {
         e.insert(A::<10>(1.0));
         e.insert(A::<11>(1.0));
         e.insert(A::<12>(1.0));
-        stage.run(&mut world);
+        schedule.run(&mut world);
         group.bench_with_input(
             BenchmarkId::new("par_for_each", archetype_count),
             &archetype_count,
             |bencher, &_| {
                 bencher.iter(|| {
-                    stage.run(&mut world);
+                    schedule.run(&mut world);
                 })
             },
         );

benches/benches/bevy_ecs/scheduling/mod.rs

@@ -2,11 +2,9 @@ use criterion::criterion_group;
 
 mod run_criteria;
 mod schedule;
-mod stages;
 
 use run_criteria::*;
 use schedule::*;
-use stages::*;
 
 criterion_group!(
     scheduling_benches,

benches/benches/bevy_ecs/scheduling/run_criteria.rs

@@ -1,10 +1,6 @@
-use bevy_ecs::{prelude::*, schedule::ShouldRun};
+use bevy_ecs::prelude::*;
 use criterion::Criterion;
 
-fn run_stage(stage: &mut SystemStage, world: &mut World) {
-    stage.run(world);
-}
-
 /// Labels for run criteria which either always return yes, or always return no.
 #[derive(RunCriteriaLabel)]
 enum Always {
@@ -22,22 +18,22 @@ pub fn run_criteria_yes(criterion: &mut Criterion) {
         ShouldRun::Yes
     }
     for amount in 0..21 {
-        let mut stage = SystemStage::parallel();
-        stage.add_system(empty.with_run_criteria(always_yes));
+        let mut schedule = Schedule::parallel();
+        schedule.add_system(empty.with_run_criteria(always_yes));
         for _ in 0..amount {
             // TODO: should change this to use a label or have another bench that uses a label instead
-            stage
+            schedule
                 .add_system(empty.with_run_criteria(always_yes))
                 .add_system(empty.with_run_criteria(always_yes))
                 .add_system(empty.with_run_criteria(always_yes))
                 .add_system(empty.with_run_criteria(always_yes))
                 .add_system(empty.with_run_criteria(always_yes));
         }
         // run once to initialize systems
-        run_stage(&mut stage, &mut world);
+        run_schedule(&mut schedule, &mut world);
         group.bench_function(&format!("{:03}_systems", 5 * amount + 1), |bencher| {
             bencher.iter(|| {
-                run_stage(&mut stage, &mut world);
+                run_schedule(&mut schedule, &mut world);
             });
         });
     }
@@ -54,21 +50,21 @@ pub fn run_criteria_no(criterion: &mut Criterion) {
         ShouldRun::No
     }
     for amount in 0..21 {
-        let mut stage = SystemStage::parallel();
-        stage.add_system(empty.with_run_criteria(always_no));
+        let mut schedule = Schedule::parallel();
+        schedule.add_system(empty.with_run_criteria(always_no));
         for _ in 0..amount {
-            stage
+            schedule
                 .add_system(empty.with_run_criteria(always_no))
                 .add_system(empty.with_run_criteria(always_no))
                 .add_system(empty.with_run_criteria(always_no))
                 .add_system(empty.with_run_criteria(always_no))
                 .add_system(empty.with_run_criteria(always_no));
         }
         // run once to initialize systems
-        run_stage(&mut stage, &mut world);
+        run_schedule(&mut schedule, &mut world);
         group.bench_function(&format!("{:03}_systems", 5 * amount + 1), |bencher| {
             bencher.iter(|| {
-                run_stage(&mut stage, &mut world);
+                run_schedule(&mut schedule, &mut world);
             });
         });
     }
@@ -85,22 +81,22 @@ pub fn run_criteria_yes_with_labels(criterion: &mut Criterion) {
         ShouldRun::Yes
     }
     for amount in 0..21 {
-        let mut stage = SystemStage::parallel();
+        let mut schedule = Schedule::parallel();
 
-        stage.add_system(empty.with_run_criteria(always_yes.label(Always::Yes)));
+        schedule.add_system(empty.with_run_criteria(always_yes.in_set(Always::Yes)));
         for _ in 0..amount {
-            stage
+            schedule
                 .add_system(empty.with_run_criteria(Always::Yes))
                 .add_system(empty.with_run_criteria(Always::Yes))
                 .add_system(empty.with_run_criteria(Always::Yes))
                 .add_system(empty.with_run_criteria(Always::Yes))
                 .add_system(empty.with_run_criteria(Always::Yes));
         }
         // run once to initialize systems
-        run_stage(&mut stage, &mut world);
+        run_schedule(&mut schedule, &mut world);
         group.bench_function(&format!("{:03}_systems", 5 * amount + 1), |bencher| {
             bencher.iter(|| {
-                run_stage(&mut stage, &mut world);
+                run_schedule(&mut schedule, &mut world);
             });
         });
     }
@@ -117,22 +113,22 @@ pub fn run_criteria_no_with_labels(criterion: &mut Criterion) {
         ShouldRun::No
     }
     for amount in 0..21 {
-        let mut stage = SystemStage::parallel();
+        let mut schedule = Schedule::parallel();
 
-        stage.add_system(empty.with_run_criteria(always_no.label(Always::No)));
+        schedule.add_system(empty.with_run_criteria(always_no.in_set(Always::No)));
         for _ in 0..amount {
-            stage
+            schedule
                 .add_system(empty.with_run_criteria(Always::No))
                 .add_system(empty.with_run_criteria(Always::No))
                 .add_system(empty.with_run_criteria(Always::No))
                 .add_system(empty.with_run_criteria(Always::No))
                 .add_system(empty.with_run_criteria(Always::No));
         }
         // run once to initialize systems
-        run_stage(&mut stage, &mut world);
+        run_schedule(&mut schedule, &mut world);
         group.bench_function(&format!("{:03}_systems", 5 * amount + 1), |bencher| {
             bencher.iter(|| {
-                run_stage(&mut stage, &mut world);
+                run_schedule(&mut schedule, &mut world);
             });
         });
     }
@@ -153,21 +149,21 @@ pub fn run_criteria_yes_with_query(criterion: &mut Criterion) {
         query.single().0.into()
     }
     for amount in 0..21 {
-        let mut stage = SystemStage::parallel();
-        stage.add_system(empty.with_run_criteria(yes_with_query));
+        let mut schedule = Schedule::parallel();
+        schedule.add_system(empty.with_run_criteria(yes_with_query));
         for _ in 0..amount {
-            stage
+            schedule
                 .add_system(empty.with_run_criteria(yes_with_query))
                 .add_system(empty.with_run_criteria(yes_with_query))
                 .add_system(empty.with_run_criteria(yes_with_query))
                 .add_system(empty.with_run_criteria(yes_with_query))
                 .add_system(empty.with_run_criteria(yes_with_query));
         }
         // run once to initialize systems
-        run_stage(&mut stage, &mut world);
+        run_schedule(&mut schedule, &mut world);
         group.bench_function(&format!("{:03}_systems", 5 * amount + 1), |bencher| {
             bencher.iter(|| {
-                run_stage(&mut stage, &mut world);
+                run_schedule(&mut schedule, &mut world);
             });
         });
     }
@@ -185,21 +181,21 @@ pub fn run_criteria_yes_with_resource(criterion: &mut Criterion) {
         res.0.into()
     }
     for amount in 0..21 {
-        let mut stage = SystemStage::parallel();
-        stage.add_system(empty.with_run_criteria(yes_with_resource));
+        let mut schedule = Schedule::parallel();
+        schedule.add_system(empty.with_run_criteria(yes_with_resource));
         for _ in 0..amount {
-            stage
+            schedule
                 .add_system(empty.with_run_criteria(yes_with_resource))
                 .add_system(empty.with_run_criteria(yes_with_resource))
                 .add_system(empty.with_run_criteria(yes_with_resource))
                 .add_system(empty.with_run_criteria(yes_with_resource))
                 .add_system(empty.with_run_criteria(yes_with_resource));
         }
         // run once to initialize systems
-        run_stage(&mut stage, &mut world);
+        run_schedule(&mut schedule, &mut world);
         group.bench_function(&format!("{:03}_systems", 5 * amount + 1), |bencher| {
             bencher.iter(|| {
-                run_stage(&mut stage, &mut world);
+                run_schedule(&mut schedule, &mut world);
             });
         });
     }