Struct CommandQueue

pub struct CommandQueue { /* private fields */ }

Densely and efficiently stores a queue of heterogenous types implementing Command.

Implementations

impl CommandQueue

pub fn push(&mut self, command: impl Command)

Push a Command onto the queue.

Examples found in repository

examples/async_tasks/async_compute.rs (lines 73-95)

fn spawn_tasks(mut commands: Commands) {
    let thread_pool = AsyncComputeTaskPool::get();
    for x in 0..NUM_CUBES {
        for y in 0..NUM_CUBES {
            for z in 0..NUM_CUBES {
                // Spawn new task on the AsyncComputeTaskPool; the task will be
                // executed in the background, and the Task future returned by
                // spawn() can be used to poll for the result
                let entity = commands.spawn_empty().id();
                let task = thread_pool.spawn(async move {
                    let duration = Duration::from_secs_f32(rand::thread_rng().gen_range(0.05..5.0));

                    // Pretend this is a time-intensive function. :)
                    async_std::task::sleep(duration).await;

                    // Such hard work, all done!
                    let transform = Transform::from_xyz(x as f32, y as f32, z as f32);
                    let mut command_queue = CommandQueue::default();

                    // we use a raw command queue to pass a FnOnce(&mut World) back to be
                    // applied in a deferred manner.
                    command_queue.push(move |world: &mut World| {
                        let (box_mesh_handle, box_material_handle) = {
                            let mut system_state = SystemState::<(
                                Res<BoxMeshHandle>,
                                Res<BoxMaterialHandle>,
                            )>::new(world);
                            let (box_mesh_handle, box_material_handle) =
                                system_state.get_mut(world);

                            (box_mesh_handle.clone(), box_material_handle.clone())
                        };

                        world
                            .entity_mut(entity)
                            // Add our new `Mesh3d` and `MeshMaterial3d` to our tagged entity
                            .insert((
                                Mesh3d(box_mesh_handle),
                                MeshMaterial3d(box_material_handle),
                                transform,
                            ))
                            // Task is complete, so remove task component from entity
                            .remove::<ComputeTransform>();
                    });

                    command_queue
                });

                // Spawn new entity and add our new task as a component
                commands.entity(entity).insert(ComputeTransform(task));
            }
        }
    }
}

pub fn apply(&mut self, world: &mut World)

Execute the queued Commands in the world after applying any commands in the world’s internal queue. This clears the queue.

pub fn append(&mut self, other: &mut CommandQueue)

Take all commands from other and append them to self, leaving other empty

pub fn is_empty(&self) -> bool

Returns false if there are any commands in the queue

Trait Implementations

impl Debug for CommandQueue

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for CommandQueue

fn default() -> CommandQueue

Returns the “default value” for a type.

impl Drop for CommandQueue

fn drop(&mut self)

Executes the destructor for this type.

impl SystemBuffer for CommandQueue

fn apply(&mut self, _system_meta: &SystemMeta, world: &mut World)

Applies any deferred mutations to the World.

fn queue(&mut self, _system_meta: &SystemMeta, world: DeferredWorld<'_>)

Queues any deferred mutations to be applied at the next ApplyDeferred.

impl Send for CommandQueue

impl Sync for CommandQueue