From 59c04f84d449ecf2bb2b5dca38b1f7d1cb894efb Mon Sep 17 00:00:00 2001 From: TheRawMeatball Date: Mon, 6 Sep 2021 15:16:27 +0300 Subject: [PATCH 1/2] Remove the Stage trait --- crates/bevy_app/src/app.rs | 72 +++--- crates/bevy_core/src/label.rs | 2 +- crates/bevy_ecs/src/lib.rs | 2 +- .../src/schedule/executor_parallel.rs | 2 +- crates/bevy_ecs/src/schedule/mod.rs | 74 ++---- crates/bevy_ecs/src/schedule/stage.rs | 233 +++++++++--------- .../bevy_ecs/src/system/exclusive_system.rs | 2 +- crates/bevy_ecs/src/system/mod.rs | 2 +- crates/bevy_render/src/render_graph/graph.rs | 4 +- crates/bevy_render/src/render_graph/system.rs | 2 +- .../hierarchy/hierarchy_maintenance_system.rs | 2 +- .../src/transform_propagate_system.rs | 2 +- 12 files changed, 174 insertions(+), 225 deletions(-) diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs index 4b9a71812f083..aaa6344f3b108 100644 --- a/crates/bevy_app/src/app.rs +++ b/crates/bevy_app/src/app.rs @@ -2,9 +2,7 @@ use crate::{CoreStage, Events, Plugin, PluginGroup, PluginGroupBuilder, StartupS use bevy_ecs::{ component::{Component, ComponentDescriptor}, prelude::{FromWorld, IntoExclusiveSystem}, - schedule::{ - IntoSystemDescriptor, RunOnce, Schedule, Stage, StageLabel, State, SystemSet, SystemStage, - }, + schedule::{IntoSystemDescriptor, Schedule, StageLabel, State, SystemSet, SystemStage}, world::World, }; use bevy_utils::tracing::debug; @@ -40,6 +38,7 @@ pub struct App { pub world: World, pub runner: Box, pub schedule: Schedule, + pub startup_schedule: Schedule, } impl Default for App { @@ -49,6 +48,7 @@ impl Default for App { app.init_resource::(); app.add_default_stages() + .add_default_startup_stages() .add_event::() .add_system_to_stage(CoreStage::Last, World::clear_trackers.exclusive_system()); @@ -71,6 +71,7 @@ impl App { world: Default::default(), schedule: Default::default(), runner: Box::new(run_once), + startup_schedule: Default::default(), } } @@ -109,69 +110,60 @@ impl App { (runner)(app); } - pub fn add_stage(&mut self, label: impl StageLabel, stage: S) -> &mut Self { + pub fn add_stage(&mut self, label: impl StageLabel, stage: SystemStage) -> &mut Self { self.schedule.add_stage(label, stage); self } - pub fn add_stage_after( + pub fn add_stage_after( &mut self, target: impl StageLabel, label: impl StageLabel, - stage: S, + stage: SystemStage, ) -> &mut Self { self.schedule.add_stage_after(target, label, stage); self } - pub fn add_stage_before( + pub fn add_stage_before( &mut self, target: impl StageLabel, label: impl StageLabel, - stage: S, + stage: SystemStage, ) -> &mut Self { self.schedule.add_stage_before(target, label, stage); self } - pub fn add_startup_stage(&mut self, label: impl StageLabel, stage: S) -> &mut Self { - self.schedule - .stage(CoreStage::Startup, |schedule: &mut Schedule| { - schedule.add_stage(label, stage) - }); + pub fn add_startup_stage(&mut self, label: impl StageLabel, stage: SystemStage) -> &mut Self { + self.startup_schedule.add_stage(label, stage); self } - pub fn add_startup_stage_after( + pub fn add_startup_stage_after( &mut self, target: impl StageLabel, label: impl StageLabel, - stage: S, + stage: SystemStage, ) -> &mut Self { - self.schedule - .stage(CoreStage::Startup, |schedule: &mut Schedule| { - schedule.add_stage_after(target, label, stage) - }); + self.startup_schedule.add_stage_after(target, label, stage); self } - pub fn add_startup_stage_before( + pub fn add_startup_stage_before( &mut self, target: impl StageLabel, label: impl StageLabel, - stage: S, + stage: SystemStage, ) -> &mut Self { - self.schedule - .stage(CoreStage::Startup, |schedule: &mut Schedule| { - schedule.add_stage_before(target, label, stage) - }); + self.startup_schedule.add_stage_before(target, label, stage); self } - pub fn stage &mut T>( + pub fn stage( &mut self, label: impl StageLabel, - func: F, + func: impl FnOnce(&mut SystemStage) -> &mut SystemStage, ) -> &mut Self { self.schedule.stage(label, func); self @@ -266,10 +258,8 @@ impl App { stage_label: impl StageLabel, system: impl IntoSystemDescriptor, ) -> &mut Self { - self.schedule - .stage(CoreStage::Startup, |schedule: &mut Schedule| { - schedule.add_system_to_stage(stage_label, system) - }); + self.startup_schedule + .add_system_to_stage(stage_label, system); self } @@ -278,10 +268,8 @@ impl App { stage_label: impl StageLabel, system_set: SystemSet, ) -> &mut Self { - self.schedule - .stage(CoreStage::Startup, |schedule: &mut Schedule| { - schedule.add_system_set_to_stage(stage_label, system_set) - }); + self.startup_schedule + .add_system_set_to_stage(stage_label, system_set); self } @@ -312,20 +300,18 @@ impl App { pub fn add_default_stages(&mut self) -> &mut Self { self.add_stage(CoreStage::First, SystemStage::parallel()) - .add_stage( - CoreStage::Startup, - Schedule::default() - .with_run_criteria(RunOnce::default()) - .with_stage(StartupStage::PreStartup, SystemStage::parallel()) - .with_stage(StartupStage::Startup, SystemStage::parallel()) - .with_stage(StartupStage::PostStartup, SystemStage::parallel()), - ) .add_stage(CoreStage::PreUpdate, SystemStage::parallel()) .add_stage(CoreStage::Update, SystemStage::parallel()) .add_stage(CoreStage::PostUpdate, SystemStage::parallel()) .add_stage(CoreStage::Last, SystemStage::parallel()) } + pub fn add_default_startup_stages(&mut self) -> &mut Self { + self.add_startup_stage(StartupStage::PreStartup, SystemStage::parallel()) + .add_startup_stage(StartupStage::Startup, SystemStage::parallel()) + .add_startup_stage(StartupStage::PostStartup, SystemStage::parallel()) + } + /// Setup the application to manage events of type `T`. /// /// This is done by adding a `Resource` of type `Events::`, diff --git a/crates/bevy_core/src/label.rs b/crates/bevy_core/src/label.rs index 6c99bc76d8eea..6bc3b6451aa8b 100644 --- a/crates/bevy_core/src/label.rs +++ b/crates/bevy_core/src/label.rs @@ -122,7 +122,7 @@ pub(crate) fn entity_labels_system( #[cfg(test)] mod tests { use bevy_ecs::{ - schedule::{Schedule, Stage, SystemStage}, + schedule::{Schedule, SystemStage}, world::World, }; diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs index c51925b710569..b3b55cfc2cda7 100644 --- a/crates/bevy_ecs/src/lib.rs +++ b/crates/bevy_ecs/src/lib.rs @@ -26,7 +26,7 @@ pub mod prelude { schedule::{ AmbiguitySetLabel, ExclusiveSystemDescriptorCoercion, ParallelSystemDescriptorCoercion, RunCriteria, RunCriteriaDescriptorCoercion, RunCriteriaLabel, RunCriteriaPiping, - Schedule, Stage, StageLabel, State, SystemLabel, SystemSet, SystemStage, + Schedule, StageLabel, State, SystemLabel, SystemSet, SystemStage, }, system::{ Commands, ConfigurableSystem, In, IntoChainSystem, IntoExclusiveSystem, IntoSystem, diff --git a/crates/bevy_ecs/src/schedule/executor_parallel.rs b/crates/bevy_ecs/src/schedule/executor_parallel.rs index 42cd1318980c6..cabaebfc0f62e 100644 --- a/crates/bevy_ecs/src/schedule/executor_parallel.rs +++ b/crates/bevy_ecs/src/schedule/executor_parallel.rs @@ -315,7 +315,7 @@ enum SchedulingEvent { mod tests { use super::SchedulingEvent::{self, *}; use crate::{ - schedule::{SingleThreadedExecutor, Stage, SystemStage}, + schedule::{SingleThreadedExecutor, SystemStage}, system::{NonSend, Query, Res, ResMut}, world::World, }; diff --git a/crates/bevy_ecs/src/schedule/mod.rs b/crates/bevy_ecs/src/schedule/mod.rs index a1c386446c5d0..8dabcaaf09800 100644 --- a/crates/bevy_ecs/src/schedule/mod.rs +++ b/crates/bevy_ecs/src/schedule/mod.rs @@ -27,32 +27,32 @@ use bevy_utils::HashMap; #[derive(Default)] pub struct Schedule { - stages: HashMap>, + stages: HashMap, stage_order: Vec, run_criteria: BoxedRunCriteria, } impl Schedule { - pub fn with_stage(mut self, label: impl StageLabel, stage: S) -> Self { + pub fn with_stage(mut self, label: impl StageLabel, stage: SystemStage) -> Self { self.add_stage(label, stage); self } - pub fn with_stage_after( + pub fn with_stage_after( mut self, target: impl StageLabel, label: impl StageLabel, - stage: S, + stage: SystemStage, ) -> Self { self.add_stage_after(target, label, stage); self } - pub fn with_stage_before( + pub fn with_stage_before( mut self, target: impl StageLabel, label: impl StageLabel, - stage: S, + stage: SystemStage, ) -> Self { self.add_stage_before(target, label, stage); self @@ -80,21 +80,21 @@ impl Schedule { self } - pub fn add_stage(&mut self, label: impl StageLabel, stage: S) -> &mut Self { + pub fn add_stage(&mut self, label: impl StageLabel, stage: SystemStage) -> &mut Self { let label: Box = Box::new(label); self.stage_order.push(label.clone()); - let prev = self.stages.insert(label.clone(), Box::new(stage)); + let prev = self.stages.insert(label.clone(), stage); if prev.is_some() { panic!("Stage already exists: {:?}.", label); } self } - pub fn add_stage_after( + pub fn add_stage_after( &mut self, target: impl StageLabel, label: impl StageLabel, - stage: S, + stage: SystemStage, ) -> &mut Self { let label: Box = Box::new(label); let target = &target as &dyn StageLabel; @@ -107,18 +107,18 @@ impl Schedule { .unwrap_or_else(|| panic!("Target stage does not exist: {:?}.", target)); self.stage_order.insert(target_index + 1, label.clone()); - let prev = self.stages.insert(label.clone(), Box::new(stage)); + let prev = self.stages.insert(label.clone(), stage); if prev.is_some() { panic!("Stage already exists: {:?}.", label); } self } - pub fn add_stage_before( + pub fn add_stage_before( &mut self, target: impl StageLabel, label: impl StageLabel, - stage: S, + stage: SystemStage, ) -> &mut Self { let label: Box = Box::new(label); let target = &target as &dyn StageLabel; @@ -131,7 +131,7 @@ impl Schedule { .unwrap_or_else(|| panic!("Target stage does not exist: {:?}.", target)); self.stage_order.insert(target_index, label.clone()); - let prev = self.stages.insert(label.clone(), Box::new(stage)); + let prev = self.stages.insert(label.clone(), stage); if prev.is_some() { panic!("Stage already exists: {:?}.", label); } @@ -154,7 +154,7 @@ impl Schedule { } let stage = self - .get_stage_mut::(&stage_label) + .get_stage_mut(&stage_label) .unwrap_or_else(move || stage_not_found(&stage_label)); stage.add_system(system); self @@ -170,31 +170,27 @@ impl Schedule { }) } - pub fn stage &mut T>( + pub fn stage( &mut self, label: impl StageLabel, - func: F, + func: impl FnOnce(&mut SystemStage) -> &mut SystemStage, ) -> &mut Self { - let stage = self.get_stage_mut::(&label).unwrap_or_else(move || { + let stage = self.get_stage_mut(&label).unwrap_or_else(move || { panic!("stage '{:?}' does not exist or is the wrong type", label) }); func(stage); self } - pub fn get_stage(&self, label: &dyn StageLabel) -> Option<&T> { - self.stages - .get(label) - .and_then(|stage| stage.downcast_ref::()) + pub fn get_stage(&self, label: &dyn StageLabel) -> Option<&SystemStage> { + self.stages.get(label) } - pub fn get_stage_mut(&mut self, label: &dyn StageLabel) -> Option<&mut T> { - self.stages - .get_mut(label) - .and_then(|stage| stage.downcast_mut::()) + pub fn get_stage_mut(&mut self, label: &dyn StageLabel) -> Option<&mut SystemStage> { + self.stages.get_mut(label) } - pub fn run_once(&mut self, world: &mut World) { + pub fn run(&mut self, world: &mut World) { for label in self.stage_order.iter() { #[cfg(feature = "trace")] let stage_span = @@ -207,29 +203,9 @@ impl Schedule { } /// Iterates over all of schedule's stages and their labels, in execution order. - pub fn iter_stages(&self) -> impl Iterator { + pub fn iter_stages(&self) -> impl Iterator { self.stage_order .iter() - .map(move |label| (&**label, &*self.stages[label])) - } -} - -impl Stage for Schedule { - fn run(&mut self, world: &mut World) { - loop { - match self.run_criteria.should_run(world) { - ShouldRun::No => return, - ShouldRun::Yes => { - self.run_once(world); - return; - } - ShouldRun::YesAndCheckAgain => { - self.run_once(world); - } - ShouldRun::NoAndCheckAgain => { - panic!("`NoAndCheckAgain` would loop infinitely in this situation.") - } - } - } + .map(move |label| (&**label, &self.stages[label])) } } diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs index 9d5dda4bdf385..eb4e36ec4c45b 100644 --- a/crates/bevy_ecs/src/schedule/stage.rs +++ b/crates/bevy_ecs/src/schedule/stage.rs @@ -12,20 +12,11 @@ use crate::{ world::{World, WorldId}, }; use bevy_utils::{tracing::info, HashMap, HashSet}; -use downcast_rs::{impl_downcast, Downcast}; use fixedbitset::FixedBitSet; use std::fmt::Debug; use super::IntoSystemDescriptor; -pub trait Stage: Downcast + Send + Sync { - /// Runs the stage; this happens once per update. - /// Implementors must initialize all of their state and systems before running the first time. - fn run(&mut self, world: &mut World); -} - -impl_downcast!(Stage); - /// When this resource is present in the `App`'s `Resources`, /// each `SystemStage` will log a report containing /// pairs of systems with ambiguous execution order. @@ -626,119 +617,8 @@ impl SystemStage { } Ok(labels) } -} - -/// Sorts given system containers topologically, populates their resolved dependencies -/// and run criteria. -fn process_systems( - systems: &mut Vec, - run_criteria_labels: &HashMap, -) -> Result<(), DependencyGraphError>> { - let mut graph = graph_utils::build_dependency_graph(systems); - let order = graph_utils::topological_order(&graph)?; - let mut order_inverted = order.iter().enumerate().collect::>(); - order_inverted.sort_unstable_by_key(|(_, &key)| key); - for (index, container) in systems.iter_mut().enumerate() { - if let Some(index) = container.run_criteria_label().map(|label| { - *run_criteria_labels - .get(label) - .unwrap_or_else(|| panic!("No run criteria with label {:?} found.", label)) - }) { - container.set_run_criteria(index); - } - container.set_dependencies( - graph - .get_mut(&index) - .unwrap() - .drain() - .map(|(index, _)| order_inverted[index].0), - ); - } - let mut temp = systems.drain(..).map(Some).collect::>(); - for index in order { - systems.push(temp[index].take().unwrap()); - } - Ok(()) -} - -/// Returns vector containing all pairs of indices of systems with ambiguous execution order, -/// along with specific components that have triggered the warning. -/// Systems must be topologically sorted beforehand. -fn find_ambiguities(systems: &[impl SystemContainer]) -> Vec<(usize, usize, Vec)> { - let mut ambiguity_set_labels = HashMap::default(); - for set in systems.iter().flat_map(|c| c.ambiguity_sets()) { - let len = ambiguity_set_labels.len(); - ambiguity_set_labels.entry(set).or_insert(len); - } - let mut all_ambiguity_sets = Vec::::with_capacity(systems.len()); - let mut all_dependencies = Vec::::with_capacity(systems.len()); - let mut all_dependants = Vec::::with_capacity(systems.len()); - for (index, container) in systems.iter().enumerate() { - let mut ambiguity_sets = FixedBitSet::with_capacity(ambiguity_set_labels.len()); - for set in container.ambiguity_sets() { - ambiguity_sets.insert(ambiguity_set_labels[set]); - } - all_ambiguity_sets.push(ambiguity_sets); - let mut dependencies = FixedBitSet::with_capacity(systems.len()); - for &dependency in container.dependencies() { - dependencies.union_with(&all_dependencies[dependency]); - dependencies.insert(dependency); - all_dependants[dependency].insert(index); - } - - all_dependants.push(FixedBitSet::with_capacity(systems.len())); - all_dependencies.push(dependencies); - } - for index in (0..systems.len()).rev() { - let mut dependants = FixedBitSet::with_capacity(systems.len()); - for dependant in all_dependants[index].ones() { - dependants.union_with(&all_dependants[dependant]); - dependants.insert(dependant); - } - all_dependants[index] = dependants; - } - let mut all_relations = all_dependencies - .drain(..) - .zip(all_dependants.drain(..)) - .enumerate() - .map(|(index, (dependencies, dependants))| { - let mut relations = FixedBitSet::with_capacity(systems.len()); - relations.union_with(&dependencies); - relations.union_with(&dependants); - relations.insert(index); - relations - }) - .collect::>(); - let mut ambiguities = Vec::new(); - let full_bitset: FixedBitSet = (0..systems.len()).collect(); - let mut processed = FixedBitSet::with_capacity(systems.len()); - for (index_a, relations) in all_relations.drain(..).enumerate() { - // TODO: prove that `.take(index_a)` would be correct here, and uncomment it if so. - for index_b in full_bitset.difference(&relations) - // .take(index_a) - { - if !processed.contains(index_b) - && all_ambiguity_sets[index_a].is_disjoint(&all_ambiguity_sets[index_b]) - { - let a_access = systems[index_a].component_access(); - let b_access = systems[index_b].component_access(); - if let (Some(a), Some(b)) = (a_access, b_access) { - let conflicts = a.get_conflicts(b); - if !conflicts.is_empty() { - ambiguities.push((index_a, index_b, conflicts)) - } - } else { - ambiguities.push((index_a, index_b, Vec::new())); - } - } - } - processed.insert(index_a); - } - ambiguities -} -impl Stage for SystemStage { - fn run(&mut self, world: &mut World) { + pub fn run(&mut self, world: &mut World) { if let Some(world_id) = self.world_id { assert!( world.id() == world_id, @@ -890,6 +770,115 @@ impl Stage for SystemStage { } } +/// Sorts given system containers topologically, populates their resolved dependencies +/// and run criteria. +fn process_systems( + systems: &mut Vec, + run_criteria_labels: &HashMap, +) -> Result<(), DependencyGraphError>> { + let mut graph = graph_utils::build_dependency_graph(systems); + let order = graph_utils::topological_order(&graph)?; + let mut order_inverted = order.iter().enumerate().collect::>(); + order_inverted.sort_unstable_by_key(|(_, &key)| key); + for (index, container) in systems.iter_mut().enumerate() { + if let Some(index) = container.run_criteria_label().map(|label| { + *run_criteria_labels + .get(label) + .unwrap_or_else(|| panic!("No run criteria with label {:?} found.", label)) + }) { + container.set_run_criteria(index); + } + container.set_dependencies( + graph + .get_mut(&index) + .unwrap() + .drain() + .map(|(index, _)| order_inverted[index].0), + ); + } + let mut temp = systems.drain(..).map(Some).collect::>(); + for index in order { + systems.push(temp[index].take().unwrap()); + } + Ok(()) +} + +/// Returns vector containing all pairs of indices of systems with ambiguous execution order, +/// along with specific components that have triggered the warning. +/// Systems must be topologically sorted beforehand. +fn find_ambiguities(systems: &[impl SystemContainer]) -> Vec<(usize, usize, Vec)> { + let mut ambiguity_set_labels = HashMap::default(); + for set in systems.iter().flat_map(|c| c.ambiguity_sets()) { + let len = ambiguity_set_labels.len(); + ambiguity_set_labels.entry(set).or_insert(len); + } + let mut all_ambiguity_sets = Vec::::with_capacity(systems.len()); + let mut all_dependencies = Vec::::with_capacity(systems.len()); + let mut all_dependants = Vec::::with_capacity(systems.len()); + for (index, container) in systems.iter().enumerate() { + let mut ambiguity_sets = FixedBitSet::with_capacity(ambiguity_set_labels.len()); + for set in container.ambiguity_sets() { + ambiguity_sets.insert(ambiguity_set_labels[set]); + } + all_ambiguity_sets.push(ambiguity_sets); + let mut dependencies = FixedBitSet::with_capacity(systems.len()); + for &dependency in container.dependencies() { + dependencies.union_with(&all_dependencies[dependency]); + dependencies.insert(dependency); + all_dependants[dependency].insert(index); + } + + all_dependants.push(FixedBitSet::with_capacity(systems.len())); + all_dependencies.push(dependencies); + } + for index in (0..systems.len()).rev() { + let mut dependants = FixedBitSet::with_capacity(systems.len()); + for dependant in all_dependants[index].ones() { + dependants.union_with(&all_dependants[dependant]); + dependants.insert(dependant); + } + all_dependants[index] = dependants; + } + let mut all_relations = all_dependencies + .drain(..) + .zip(all_dependants.drain(..)) + .enumerate() + .map(|(index, (dependencies, dependants))| { + let mut relations = FixedBitSet::with_capacity(systems.len()); + relations.union_with(&dependencies); + relations.union_with(&dependants); + relations.insert(index); + relations + }) + .collect::>(); + let mut ambiguities = Vec::new(); + let full_bitset: FixedBitSet = (0..systems.len()).collect(); + let mut processed = FixedBitSet::with_capacity(systems.len()); + for (index_a, relations) in all_relations.drain(..).enumerate() { + // TODO: prove that `.take(index_a)` would be correct here, and uncomment it if so. + for index_b in full_bitset.difference(&relations) + // .take(index_a) + { + if !processed.contains(index_b) + && all_ambiguity_sets[index_a].is_disjoint(&all_ambiguity_sets[index_b]) + { + let a_access = systems[index_a].component_access(); + let b_access = systems[index_b].component_access(); + if let (Some(a), Some(b)) = (a_access, b_access) { + let conflicts = a.get_conflicts(b); + if !conflicts.is_empty() { + ambiguities.push((index_a, index_b, conflicts)) + } + } else { + ambiguities.push((index_a, index_b, Vec::new())); + } + } + } + processed.insert(index_a); + } + ambiguities +} + #[cfg(test)] mod tests { use crate::{ @@ -898,7 +887,7 @@ mod tests { schedule::{ BoxedSystemLabel, ExclusiveSystemDescriptorCoercion, ParallelSystemDescriptorCoercion, RunCriteria, RunCriteriaDescriptorCoercion, RunCriteriaPiping, ShouldRun, - SingleThreadedExecutor, Stage, SystemSet, SystemStage, + SingleThreadedExecutor, SystemSet, SystemStage, }, system::{In, IntoExclusiveSystem, IntoSystem, Local, Query, ResMut}, world::World, diff --git a/crates/bevy_ecs/src/system/exclusive_system.rs b/crates/bevy_ecs/src/system/exclusive_system.rs index 7050355b6b8fe..3f658bf74a566 100644 --- a/crates/bevy_ecs/src/system/exclusive_system.rs +++ b/crates/bevy_ecs/src/system/exclusive_system.rs @@ -127,7 +127,7 @@ mod tests { use crate::{ entity::Entity, query::With, - schedule::{Stage, SystemStage}, + schedule::SystemStage, system::{Commands, IntoExclusiveSystem, Query, ResMut}, world::World, }; diff --git a/crates/bevy_ecs/src/system/mod.rs b/crates/bevy_ecs/src/system/mod.rs index d4fd0ad79909c..6e083bc0aa009 100644 --- a/crates/bevy_ecs/src/system/mod.rs +++ b/crates/bevy_ecs/src/system/mod.rs @@ -25,7 +25,7 @@ mod tests { component::Components, entity::{Entities, Entity}, query::{Added, Changed, Or, QueryState, With, Without}, - schedule::{Schedule, Stage, SystemStage}, + schedule::{Schedule, SystemStage}, system::{ ConfigurableSystem, IntoExclusiveSystem, IntoSystem, Local, NonSend, NonSendMut, Query, QuerySet, RemovedComponents, Res, ResMut, System, SystemState, diff --git a/crates/bevy_render/src/render_graph/graph.rs b/crates/bevy_render/src/render_graph/graph.rs index 503bce7578e09..c34a1962bec94 100644 --- a/crates/bevy_render/src/render_graph/graph.rs +++ b/crates/bevy_render/src/render_graph/graph.rs @@ -45,9 +45,7 @@ impl RenderGraph { T: SystemNode + 'static, { let schedule = self.system_node_schedule.as_mut().unwrap(); - let stage = schedule - .get_stage_mut::(&RenderGraphUpdate) - .unwrap(); + let stage = schedule.get_stage_mut(&RenderGraphUpdate).unwrap(); stage.add_system(node.get_system()); self.add_node(name, node) } diff --git a/crates/bevy_render/src/render_graph/system.rs b/crates/bevy_render/src/render_graph/system.rs index 650e318c4ab59..05926df8a455e 100644 --- a/crates/bevy_render/src/render_graph/system.rs +++ b/crates/bevy_render/src/render_graph/system.rs @@ -1,5 +1,5 @@ use super::RenderGraph; -use bevy_ecs::{schedule::Stage, world::World}; +use bevy_ecs::world::World; pub fn render_graph_schedule_executor_system(world: &mut World) { // run render graph systems diff --git a/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs b/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs index 3f7491f659b56..c52cabe0e07bf 100644 --- a/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs +++ b/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs @@ -74,7 +74,7 @@ pub fn parent_update_system( #[cfg(test)] mod test { use bevy_ecs::{ - schedule::{Schedule, Stage, SystemStage}, + schedule::{Schedule, SystemStage}, system::CommandQueue, world::World, }; diff --git a/crates/bevy_transform/src/transform_propagate_system.rs b/crates/bevy_transform/src/transform_propagate_system.rs index a4ab7aadcdf89..d72ea0e871b3d 100644 --- a/crates/bevy_transform/src/transform_propagate_system.rs +++ b/crates/bevy_transform/src/transform_propagate_system.rs @@ -76,7 +76,7 @@ fn propagate_recursive( #[cfg(test)] mod test { use bevy_ecs::{ - schedule::{Schedule, Stage, SystemStage}, + schedule::{Schedule, SystemStage}, system::{CommandQueue, Commands}, world::World, }; From 99bee252cc483028d316e3635e604b0d01b608f1 Mon Sep 17 00:00:00 2001 From: TheRawMeatball Date: Mon, 6 Sep 2021 15:21:53 +0300 Subject: [PATCH 2/2] cleanup --- crates/bevy_app/src/app.rs | 1 + crates/bevy_app/src/schedule_runner.rs | 1 + crates/bevy_ui/src/update.rs | 2 +- crates/bevy_winit/src/lib.rs | 1 + examples/app/custom_loop.rs | 1 + 5 files changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs index aaa6344f3b108..cff2e2a57e428 100644 --- a/crates/bevy_app/src/app.rs +++ b/crates/bevy_app/src/app.rs @@ -565,6 +565,7 @@ impl App { } fn run_once(mut app: App) { + app.startup_schedule.run(&mut app.world); app.update(); } diff --git a/crates/bevy_app/src/schedule_runner.rs b/crates/bevy_app/src/schedule_runner.rs index c3a897d5eced1..b05a70857154e 100644 --- a/crates/bevy_app/src/schedule_runner.rs +++ b/crates/bevy_app/src/schedule_runner.rs @@ -58,6 +58,7 @@ impl Plugin for ScheduleRunnerPlugin { .to_owned(); app.set_runner(move |mut app: App| { let mut app_exit_event_reader = ManualEventReader::::default(); + app.startup_schedule.run(&mut app.world); match settings.run_mode { RunMode::Once => { app.update(); diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs index 42876a7c30c07..8bc70e8d92448 100644 --- a/crates/bevy_ui/src/update.rs +++ b/crates/bevy_ui/src/update.rs @@ -53,7 +53,7 @@ fn update_hierarchy( #[cfg(test)] mod tests { use bevy_ecs::{ - schedule::{Schedule, Stage, SystemStage}, + schedule::{Schedule, SystemStage}, system::{CommandQueue, Commands}, world::World, }; diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs index af072b7a60f9f..f87cff3fca926 100644 --- a/crates/bevy_winit/src/lib.rs +++ b/crates/bevy_winit/src/lib.rs @@ -222,6 +222,7 @@ pub fn winit_runner_any_thread(app: App) { } pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) { + app.startup_schedule.run(&mut app.world); let mut create_window_event_reader = ManualEventReader::::default(); let mut app_exit_event_reader = ManualEventReader::::default(); app.world.insert_non_send(event_loop.create_proxy()); diff --git a/examples/app/custom_loop.rs b/examples/app/custom_loop.rs index c422fc2c8f907..fe6106367529d 100644 --- a/examples/app/custom_loop.rs +++ b/examples/app/custom_loop.rs @@ -7,6 +7,7 @@ struct Input(String); /// lines from stdin and prints them from within the ecs. fn my_runner(mut app: App) { println!("Type stuff into the console"); + app.startup_schedule.run(&mut app.world); for line in io::stdin().lock().lines() { { let mut input = app.world.get_resource_mut::().unwrap();