Struct bevy::ecs::query::QueryParIter

pub struct QueryParIter<'w, 's, D, F>
where
    D: QueryData,
    F: QueryFilter,
{ /* private fields */ }

A parallel iterator over query results of a Query.

This struct is created by the Query::par_iter and Query::par_iter_mut methods.

Implementations

impl<'w, 's, D, F> QueryParIter<'w, 's, D, F>

where D: QueryData, F: QueryFilter,

pub fn batching_strategy( self, strategy: BatchingStrategy ) -> QueryParIter<'w, 's, D, F>

Changes the batching strategy used when iterating.

For more information on how this affects the resultant iteration, see BatchingStrategy.

Examples found in repository

examples/ecs/parallel_query.rs (line 61)

fn bounce_system(windows: Query<&Window>, mut sprites: Query<(&Transform, &mut Velocity)>) {
    let window = windows.single();
    let width = window.width();
    let height = window.height();
    let left = width / -2.0;
    let right = width / 2.0;
    let bottom = height / -2.0;
    let top = height / 2.0;
    // The default batch size can also be overridden.
    // In this case a batch size of 32 is chosen to limit the overhead of
    // ParallelIterator, since negating a vector is very inexpensive.
    sprites
        .par_iter_mut()
        .batching_strategy(BatchingStrategy::fixed(32))
        .for_each(|(transform, mut v)| {
            if !(left < transform.translation.x
                && transform.translation.x < right
                && bottom < transform.translation.y
                && transform.translation.y < top)
            {
                // For simplicity, just reverse the velocity; don't use realistic bounces
                v.0 = -v.0;
            }
        });
}

pub fn for_each<FN>(self, func: FN)

where FN: Fn(<D as WorldQuery>::Item<'w>) + Send + Sync + Clone,

Runs func on each query result in parallel.

Panics

If the ComputeTaskPool is not initialized. If using this from a query that is being initialized and run from the ECS scheduler, this should never panic.

Examples found in repository

examples/ecs/parallel_query.rs (lines 42-44)

fn move_system(mut sprites: Query<(&mut Transform, &Velocity)>) {
    // Compute the new location of each sprite in parallel on the
    // ComputeTaskPool
    //
    // This example is only for demonstrative purposes. Using a
    // ParallelIterator for an inexpensive operation like addition on only 128
    // elements will not typically be faster than just using a normal Iterator.
    // See the ParallelIterator documentation for more information on when
    // to use or not use ParallelIterator over a normal Iterator.
    sprites
        .par_iter_mut()
        .for_each(|(mut transform, velocity)| {
            transform.translation += velocity.extend(0.0);
        });
}

// Bounce sprites outside the window
fn bounce_system(windows: Query<&Window>, mut sprites: Query<(&Transform, &mut Velocity)>) {
    let window = windows.single();
    let width = window.width();
    let height = window.height();
    let left = width / -2.0;
    let right = width / 2.0;
    let bottom = height / -2.0;
    let top = height / 2.0;
    // The default batch size can also be overridden.
    // In this case a batch size of 32 is chosen to limit the overhead of
    // ParallelIterator, since negating a vector is very inexpensive.
    sprites
        .par_iter_mut()
        .batching_strategy(BatchingStrategy::fixed(32))
        .for_each(|(transform, mut v)| {
            if !(left < transform.translation.x
                && transform.translation.x < right
                && bottom < transform.translation.y
                && transform.translation.y < top)
            {
                // For simplicity, just reverse the velocity; don't use realistic bounces
                v.0 = -v.0;
            }
        });
}

pub fn for_each_init<FN, INIT, T>(self, init: INIT, func: FN)

where FN: Fn(&mut T, <D as WorldQuery>::Item<'w>) + Send + Sync + Clone, INIT: Fn() -> T + Sync + Send + Clone,

Runs func on each query result in parallel on a value returned by init.

init may be called multiple times per thread, and the values returned may be discarded between tasks on any given thread. Callers should avoid using this function as if it were a parallel version of Iterator::fold.

Example

use bevy_utils::Parallel;
use crate::{bevy_ecs::prelude::Component, bevy_ecs::system::Query};
#[derive(Component)]
struct T;
fn system(query: Query<&T>){
    let mut queue: Parallel<usize> = Parallel::default();
    // queue.borrow_local_mut() will get or create a thread_local queue for each task/thread;
    query.par_iter().for_each_init(|| queue.borrow_local_mut(),|local_queue,item| {
        **local_queue += 1;
     });
     
    // collect value from every thread
    let entity_count: usize = queue.iter_mut().map(|v| *v).sum();
}

Panics

If the ComputeTaskPool is not initialized. If using this from a query that is being initialized and run from the ECS scheduler, this should never panic.