Try #2507:

Author: bors[bot]

crates/bevy_core/src/time/fixed_timestep.rs

@@ -3,7 +3,7 @@ use bevy_ecs::{
     archetype::{Archetype, ArchetypeComponentId},
     component::ComponentId,
     query::Access,
-    schedule::ShouldRun,
+    schedule::{ScheduleCommandQueue, ShouldRun},
     system::{IntoSystem, Local, Res, ResMut, System, SystemId},
     world::World,
 };
@@ -178,6 +178,10 @@ impl System for FixedTimestep {
         self.internal_system.apply_buffers(world)
     }
 
+    fn schedule_commands(&mut self) -> Option<ScheduleCommandQueue> {
+        self.internal_system.schedule_commands()
+    }
+
     fn initialize(&mut self, world: &mut World) {
         self.internal_system = Box::new(
             Self::prepare_system

crates/bevy_ecs/src/schedule/commands.rs

@@ -0,0 +1,121 @@
+use std::marker::PhantomData;
+
+use super::{IntoSystemDescriptor, Schedule, StageLabel};
+
+#[derive(Default)]
+pub struct ScheduleCommandQueue {
+    items: Vec<Box<dyn ScheduleCommand>>
+}
+
+impl ScheduleCommandQueue {
+    pub fn push<C>(&mut self, command: C)
+    where 
+        C: ScheduleCommand,
+    {
+        self.items.push(Box::new(command));
+    }
+
+    pub fn apply(&mut self, schedule: &mut Schedule) {
+        for command in self.items.drain(..) {
+            command.write(schedule);
+        }
+    }
+
+    pub fn transfer(&mut self, queue: &mut ScheduleCommandQueue) {
+        queue.items.extend(self.items.drain(..));
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.items.is_empty()
+    }
+}
+
+/// A [`Schedule`] mutation.
+pub trait ScheduleCommand: Send + Sync + 'static {
+    fn write(self: Box<Self>, schedule: &mut Schedule);
+}
+
+pub struct ScheduleCommands<'a> {
+    queue: &'a mut ScheduleCommandQueue
+}
+
+impl<'a> ScheduleCommands<'a> {
+    pub fn new(queue: &'a mut ScheduleCommandQueue) -> Self {
+        Self {
+            queue
+        }
+    }
+
+    pub fn insert_system<T: 'static, S, Params: 'static>(&mut self, system: T, stage_label: S)
+    where
+        T: IntoSystemDescriptor<Params> + Send + Sync,
+        S: StageLabel
+    {
+        self.queue.push(InsertSystem {
+            system: system,
+            stage_label: stage_label,
+            phantom: Default::default(),
+        });
+    }
+}
+
+pub struct InsertSystem<T, S, Params>
+where
+    T: IntoSystemDescriptor<Params>,
+    S: StageLabel
+{
+    pub system: T,
+    pub stage_label: S,
+    phantom: PhantomData<fn() -> Params>,
+}
+
+impl<T: 'static, S, Params: 'static> ScheduleCommand for InsertSystem<T, S, Params>
+where
+    T: IntoSystemDescriptor<Params> + Send + Sync,
+    S: StageLabel
+{
+    fn write(self: Box<Self>, schedule: &mut Schedule) {
+        schedule.add_system_to_stage(self.stage_label, self.system);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        schedule::{Schedule, ScheduleCommands, ScheduleCommandQueue, SystemStage},
+        system::Commands,
+        world::World,
+    };
+
+    #[test]
+    fn insert_system() {
+        fn sample_system(mut _commands: Commands) {
+
+        }
+        let mut schedule = Schedule::default();
+        schedule.add_stage("test", SystemStage::parallel());
+        let mut queue = ScheduleCommandQueue::default();
+        let mut schedule_commands = ScheduleCommands::new(&mut queue);
+        schedule_commands.insert_system(sample_system, "test");
+        queue.apply(&mut schedule);
+
+        let stage = schedule.get_stage::<SystemStage>(&"test").unwrap();
+        assert_eq!(stage.parallel_systems().len(), 1);
+    }
+
+    #[test]
+    fn insert_system_from_system() {
+        fn sample_system(mut schedule_commands: ScheduleCommands) {
+            schedule_commands.insert_system(|| {}, "test");
+        }
+
+        let mut world = World::default();
+        let mut schedule = Schedule::default();
+        schedule.add_stage("test", SystemStage::parallel());
+        schedule.add_system_to_stage("test", sample_system);
+        schedule.run_once(&mut world);
+
+        let stage = schedule.get_stage::<SystemStage>(&"test").unwrap();
+        assert_eq!(stage.parallel_systems().len(), 2);
+    }
+}

crates/bevy_ecs/src/schedule/mod.rs

@@ -8,6 +8,7 @@ mod state;
 mod system_container;
 mod system_descriptor;
 mod system_set;
+mod commands;
 
 pub use executor::*;
 pub use executor_parallel::*;
@@ -19,6 +20,7 @@ pub use state::*;
 pub use system_container::*;
 pub use system_descriptor::*;
 pub use system_set::*;
+pub use commands::*;
 
 use std::fmt::Debug;
 
@@ -198,6 +200,7 @@ impl Schedule {
     }
 
     pub fn run_once(&mut self, world: &mut World) {
+        let mut commands = ScheduleCommandQueue::default();
         for label in self.stage_order.iter() {
             #[cfg(feature = "trace")]
             let stage_span =
@@ -206,7 +209,12 @@ impl Schedule {
             let _stage_guard = stage_span.enter();
             let stage = self.stages.get_mut(label).unwrap();
             stage.run(world);
+            if let Some(mut stage_commands) = stage.commands() {
+                stage_commands.transfer(&mut commands);
+            }
         }
+
+        commands.apply(self);
     }
 
     /// Iterates over all of schedule's stages and their labels, in execution order.
@@ -235,4 +243,8 @@ impl Stage for Schedule {
             }
         }
     }
+
+    fn commands(&mut self) -> Option<ScheduleCommandQueue> {
+        None
+    }
 }

crates/bevy_ecs/src/schedule/run_criteria.rs

@@ -2,7 +2,7 @@ use crate::{
     archetype::{Archetype, ArchetypeComponentId, ArchetypeGeneration},
     component::ComponentId,
     query::Access,
-    schedule::{BoxedRunCriteriaLabel, GraphNode, RunCriteriaLabel},
+    schedule::{BoxedRunCriteriaLabel, GraphNode, RunCriteriaLabel, ScheduleCommandQueue},
     system::{BoxedSystem, IntoSystem, System, SystemId},
     world::World,
 };
@@ -450,6 +450,7 @@ impl System for RunOnce {
     }
 
     fn apply_buffers(&mut self, _world: &mut World) {}
+    fn schedule_commands(&mut self) -> Option<ScheduleCommandQueue> { None }
 
     fn initialize(&mut self, _world: &mut World) {}
 

crates/bevy_ecs/src/schedule/stage.rs

@@ -5,23 +5,24 @@ use crate::{
         BoxedRunCriteria, BoxedRunCriteriaLabel, BoxedSystemLabel, DuplicateLabelStrategy,
         ExclusiveSystemContainer, GraphNode, InsertionPoint, ParallelExecutor,
         ParallelSystemContainer, ParallelSystemExecutor, RunCriteriaContainer,
-        RunCriteriaDescriptor, RunCriteriaDescriptorOrLabel, RunCriteriaInner, ShouldRun,
-        SingleThreadedExecutor, SystemContainer, SystemDescriptor, SystemSet,
+        RunCriteriaDescriptor, RunCriteriaDescriptorOrLabel, RunCriteriaInner,
+        ShouldRun, SingleThreadedExecutor, SystemContainer, SystemDescriptor, SystemSet,
     },
-    system::System,
+    system::{System, ExclusiveSystem},
     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;
+use super::{IntoSystemDescriptor, ScheduleCommandQueue};
 
 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);
+    fn commands(&mut self) -> Option<ScheduleCommandQueue>;
 }
 
 impl_downcast!(Stage);
@@ -83,6 +84,8 @@ pub struct SystemStage {
     uninitialized_parallel: Vec<usize>,
     /// Saves the value of the World change_tick during the last tick check
     last_tick_check: u32,
+    // Contains commands for the schedule
+    schedule_commands: ScheduleCommandQueue,
 }
 
 impl SystemStage {
@@ -104,6 +107,7 @@ impl SystemStage {
             uninitialized_before_commands: vec![],
             uninitialized_at_end: vec![],
             last_tick_check: Default::default(),
+            schedule_commands: Default::default(),
         }
     }
 
@@ -805,10 +809,17 @@ impl Stage for SystemStage {
                     )
                 }
 
+                fn run_exclusive(world: &mut World, system: &mut Box<dyn ExclusiveSystem>, commands: &mut ScheduleCommandQueue) {
+                    system.run(world);
+                    if let Some(mut c) = system.schedule_commands() {
+                        c.transfer(commands);
+                    }
+                }
+
                 // Run systems that want to be at the start of stage.
                 for container in &mut self.exclusive_at_start {
                     if should_run(container, &self.run_criteria, default_should_run) {
-                        container.system_mut().run(world);
+                        run_exclusive(world, container.system_mut(), &mut self.schedule_commands);
                     }
                 }
 
@@ -823,21 +834,25 @@ impl Stage for SystemStage {
                 // Run systems that want to be between parallel systems and their command buffers.
                 for container in &mut self.exclusive_before_commands {
                     if should_run(container, &self.run_criteria, default_should_run) {
-                        container.system_mut().run(world);
+                        run_exclusive(world, container.system_mut(), &mut self.schedule_commands);
                     }
                 }
 
                 // Apply parallel systems' buffers.
                 for container in &mut self.parallel {
                     if container.should_run {
-                        container.system_mut().apply_buffers(world);
+                        let system = container.system_mut();
+                        system.apply_buffers(world);
+                        if let Some(mut commands) = system.schedule_commands() {
+                            commands.transfer(&mut self.schedule_commands);
+                        }
                     }
                 }
 
                 // Run systems that want to be at the end of stage.
                 for container in &mut self.exclusive_at_end {
                     if should_run(container, &self.run_criteria, default_should_run) {
-                        container.system_mut().run(world);
+                        run_exclusive(world, container.system_mut(), &mut self.schedule_commands);
                     }
                 }
 
@@ -885,6 +900,16 @@ impl Stage for SystemStage {
             }
         }
     }
+
+    fn commands(&mut self) -> Option<ScheduleCommandQueue> {
+        if self.schedule_commands.is_empty() {
+            return None;
+        }
+
+        let mut commands = Default::default();
+        self.schedule_commands.transfer(&mut commands);
+        Some(commands)
+    }
 }
 
 #[cfg(test)]

crates/bevy_ecs/src/system/exclusive_system.rs

@@ -1,5 +1,6 @@
 use crate::{
     archetype::ArchetypeGeneration,
+    schedule::ScheduleCommandQueue,
     system::{check_system_change_tick, BoxedSystem, IntoSystem, SystemId},
     world::World,
 };
@@ -12,6 +13,8 @@ pub trait ExclusiveSystem: Send + Sync + 'static {
 
     fn run(&mut self, world: &mut World);
 
+    fn schedule_commands(&mut self) -> Option<ScheduleCommandQueue>;
+
     fn initialize(&mut self, world: &mut World);
 
     fn check_change_tick(&mut self, change_tick: u32);
@@ -48,6 +51,10 @@ impl ExclusiveSystem for ExclusiveSystemFn {
         world.last_change_tick = saved_last_tick;
     }
 
+    fn schedule_commands(&mut self) -> Option<ScheduleCommandQueue> {
+        None
+    }
+
     fn initialize(&mut self, _: &mut World) {}
 
     fn check_change_tick(&mut self, change_tick: u32) {
@@ -101,6 +108,10 @@ impl ExclusiveSystem for ExclusiveSystemCoerced {
         self.system.apply_buffers(world);
     }
 
+    fn schedule_commands(&mut self) -> Option<ScheduleCommandQueue> {
+        self.system.schedule_commands()
+    }
+
     fn initialize(&mut self, world: &mut World) {
         self.system.initialize(world);
     }

crates/bevy_ecs/src/system/function_system.rs

@@ -7,6 +7,7 @@ use crate::{
         SystemParamFetch, SystemParamState,
     },
     world::{World, WorldId},
+    schedule::ScheduleCommandQueue,
 };
 use bevy_ecs_macros::all_tuples;
 use std::{borrow::Cow, marker::PhantomData};
@@ -383,6 +384,11 @@ where
         param_state.apply(world);
     }
 
+    fn schedule_commands(&mut self) -> Option<ScheduleCommandQueue> {
+        let param_state = self.param_state.as_mut().unwrap();
+        param_state.schedule_commands()
+    }
+
     #[inline]
     fn initialize(&mut self, world: &mut World) {
         self.param_state = Some(<Param::Fetch as SystemParamState>::init(

crates/bevy_ecs/src/system/system.rs

@@ -1,11 +1,6 @@
 use bevy_utils::tracing::warn;
 
-use crate::{
-    archetype::{Archetype, ArchetypeComponentId},
-    component::ComponentId,
-    query::Access,
-    world::World,
-};
+use crate::{archetype::{Archetype, ArchetypeComponentId}, component::ComponentId, query::Access, schedule::ScheduleCommandQueue, world::World};
 use std::borrow::Cow;
 
 /// A [`System`] identifier.
@@ -66,6 +61,7 @@ pub trait System: Send + Sync + 'static {
         unsafe { self.run_unsafe(input, world) }
     }
     fn apply_buffers(&mut self, world: &mut World);
+    fn schedule_commands(&mut self) -> Option<ScheduleCommandQueue>;
     /// Initialize the system.
     fn initialize(&mut self, _world: &mut World);
     fn check_change_tick(&mut self, change_tick: u32);