Is there a way to iterate through Query results in the same way as a Vec, or to get a Vec of entities?

[polaris64]

Following on from issue #14679 about poor performance of Query::iter_combinations_mut, is there a way I could write my own nested loop in the same way that I did in the Nannou project linked to in that issue?

Specifically I used split_at_mut on a Vec of objects in order to mutate separate elements of the Vec in the same loop. The performance is very good, so is there a way I could do something similar instead of using Query::iter_combinations_mut?

[alice-i-cecile]

Collect the entities into a Vec using query.iter_mut().collect::<Vec<_>>().

[polaris64]

Thank you! I had actually written this off mentally as I thought collecting to a Vec on every update would be far too slow, but it actually makes my project perform as well as the Nannou project (at least from a visual standpoint).

For reference, here's the new collision handler which uses this approach: -

fn handle_verlet_collisions(
    query: QueryIter<(&mut Transform, &mut VerletPhysics, &VerletProperties), ()>,
) {
    let mut entities = query.collect::<Vec<(Mut<Transform>, Mut<VerletPhysics>, &VerletProperties)>>();
    for i in 1..entities.len() {
        let (a, b) = entities.split_at_mut(i);
        let (ref mut tr1, _, pr1) = a.last_mut().unwrap();
        for (ref mut tr2, _, pr2) in b.iter_mut() {
            let mut norm = tr2.translation - tr1.translation;
            let dist = norm.length();
            if dist < pr1.radius + pr2.radius {
                let overlap = (pr1.radius + pr2.radius) - dist;
                norm = norm.normalize();
                if !pr1.pinned {
                    tr1.translation.x -= norm.x * overlap * 0.5f32;
                    tr1.translation.y -= norm.y * overlap * 0.5f32;
                }
                if !pr2.pinned {
                    tr2.translation.x += norm.x * overlap * 0.5f32;
                    tr2.translation.y += norm.y * overlap * 0.5f32;
                }
            }
        }
    }
}

Note that this isn't a system, rather it's a normal function which takes a QueryIter from the parent system. This is because of another experiment I was running to try to improve performance. I'll also make this change to the version that handles collisions as a system and I'll report back.

[polaris64]

Yes this is definitely faster, especially as the immediate performance boost was apparent even without a release build which was required before!

The updated collision check system is: -

fn handle_verlet_collisions(
    mut query: Query<(&mut Transform, &VerletProperties)>,
) {
    let mut entities = query.iter_mut().collect::<Vec<(Mut<Transform>, &VerletProperties)>>();
    for i in 1..entities.len() {
        let (a, b) = entities.split_at_mut(i);
        let (ref mut tr1, pr1) = a.last_mut().unwrap();
        for (ref mut tr2, pr2) in b.iter_mut() {
            let mut norm = tr2.translation - tr1.translation;
            let dist = norm.length();
            if dist < pr1.radius + pr2.radius {
                let overlap = (pr1.radius + pr2.radius) - dist;
                norm = norm.normalize();
                if !pr1.pinned {
                    tr1.translation.x -= norm.x * overlap * 0.5f32;
                    tr1.translation.y -= norm.y * overlap * 0.5f32;
                }
                if !pr2.pinned {
                    tr2.translation.x += norm.x * overlap * 0.5f32;
                    tr2.translation.y += norm.y * overlap * 0.5f32;
                }
            }
        }
    }
}

I wonder if something similar could be done to iter_combinations_mut in cases where K == 2?

[SkiFire13]

Would #14690 be helpful to you? In particular it would allow you to rewrite your system like this:

fn handle_verlet_collisions(
    mut query: Query<(&mut Transform, &VerletProperties)>,
) {
    let mut iter = query.iter();
    while let Some((mut tr1, pr1)) = iter.next() {
        for (mut tr2, pr2) in iter.reborrow() {
            let mut norm = tr2.translation - tr1.translation;
            let dist = norm.length();
            if dist < pr1.radius + pr2.radius {
                let overlap = (pr1.radius + pr2.radius) - dist;
                norm = norm.normalize();
                if !pr1.pinned {
                    tr1.translation.x -= norm.x * overlap * 0.5f32;
                    tr1.translation.y -= norm.y * overlap * 0.5f32;
                }
                if !pr2.pinned {
                    tr2.translation.x += norm.x * overlap * 0.5f32;
                    tr2.translation.y += norm.y * overlap * 0.5f32;
                }
            }
        }
    }
}

[C-Entropy]

@SkiFire13
Sorroy to bother here, but I can't find much help out there.
I want to use the cool reborrow(), so I configure bevy to using the git one:
bevy = { git = "https://github.com/bevyengine/bevy.git", features = ["wayland", "dynamic_linking"]} # , features = ["dynamic_linking"]
then run cargo clean and rebuild the code.

However, when build the following code:

fn update_cells(mut query: Query<(&CellIndex, &mut CellState, &mut Transform, &mut Sprite)>) {
    let mut iter = query.iter();
    while let Some((cell_index, mut cell_state_, mut transtraom, mut sprite)) = iter.next() {
        for (world_cell_index, world_cell_state, _, _) in iter.reborrow() {
            dbg("here");
        }
    }
}

cargo said:

cargo run
   Compiling cell_auto_game v0.1.0 (/home/nil/projects/playground/cell_auto_game)
error[E0599]: no method named `reborrow` found for struct `QueryIter` in the current scope
   --> src/main.rs:119:64
    |
119 |         for (world_cell_index, world_cell_state, _, _) in iter.reborrow() {
    |                                                                ^^^^^^^^
    |
help: there is a method `borrow` with a similar name
    |
119 |         for (world_cell_index, world_cell_state, _, _) in iter.borrow() {
    |                                                                ~~~~~~

For more information about this error, try `rustc --explain E0599`.
error: could not compile `cell_auto_game` (bin "cell_auto_game") due to 1 previous error

Please, point me out what I should do to work it out.

[SkiFire13]

I don't think cargo clean will prompt cargo to update git dependencies, so you might still be using an old commit without the reborrow method. Try with cargo update -p bevy instead.

Sorroy to bother here, but I can't find much help out there.

I suggest you to check out the Bevy discord, you can probably get help much faster there! Otherwise consider opening a separate issue/discussion if you have some problem instead of replying to old ones

[C-Entropy]

I have tried cargo update -p bevy, but the error remains.
I wanted to open an new discussion, but accidently open it as an new issue, and don't know how to delete it..

[akimakinai]

Isn't the QueryIter method added in #14690 named remaining, not reborrow?

[C-Entropy]

Yes, it looks like reborrow have been replaced by remaining, while the function provied by remaining is not what I expected. I need to run a nest loop for queries, but remaing just run loop for the remains.
I have also tried let copied_query = query.reborrow();, which complains about cannot borrow query as mutable more than once at a time, case it have been borrowed by query.iter_mut() already.