bevy_uniform_grid_2d 0.3.1

A simple Bevy plugin for uniform grid spatial indexing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use bevy::{
    ecs::{
        component::Component,
        entity::Entity,
        event::{EventReader, EventWriter},
        query::{Changed, With},
        system::{Commands, Query, QueryLens, ResMut},
    },
    transform::components::Transform,
};

use crate::{
    component::GridCell,
    error::GridError,
    event::{GridEvent, GridOperation, TransformGridEvent},
    resource::Grid,
};

pub(crate) fn update_grid<Marker: Component, const N: usize>(
    mut commands: Commands,
    mut grid: ResMut<Grid<Marker, N>>,
    mut transforms: Query<&Transform, With<Marker>>,
    mut changed_transforms: Query<&Transform, (Changed<Transform>, With<Marker>)>,
    mut grid_elements: Query<(Entity, Option<&mut GridCell>), With<Marker>>,
    mut grid_events: EventWriter<GridEvent>,
    mut transform_grid_events: EventReader<TransformGridEvent<Marker, N>>,
) {
    let mut grid_elements: QueryLens<(Entity, &Transform, Option<&mut GridCell>), With<Marker>> =
        if transform_grid_events.is_empty() {
            changed_transforms.join_filtered(&mut grid_elements)
        } else {
            for event in transform_grid_events.read() {
                if let Some(dimensions) = event.dimensions {
                    grid.set_dimensions(dimensions);
                };
                if let Some(spacing) = event.spacing {
                    grid.set_spacing(spacing);
                };
                if let Some(anchor) = event.anchor {
                    grid.set_anchor(anchor);
                };
            }
            grid.reset();
            transforms.join_filtered(&mut grid_elements)
        };
    for (entity, transform, current_cell) in grid_elements.query().iter_mut() {
        match grid.world_to_grid(transform.translation) {
            Ok(new_cell) => {
                let Some(mut current_cell) = current_cell else {
                    if grid.insert(entity, new_cell).is_ok() {
                        commands.entity(entity).insert(GridCell(new_cell));
                        grid_events.send(GridEvent {
                            entity,
                            operation: GridOperation::Insert { to: new_cell },
                        });
                    }
                    continue;
                };
                if new_cell != current_cell.0 {
                    let _ = grid.update(entity, current_cell.0, new_cell);
                    grid_events.send(GridEvent {
                        entity,
                        operation: GridOperation::Update {
                            from: current_cell.0,
                            to: new_cell,
                        },
                    });
                    current_cell.0 = new_cell;
                };
            }
            Err(GridError::OutOfBounds(_)) => {
                if let Some(current_cell) = current_cell {
                    let _ = grid.remove(entity, current_cell.0);
                    commands.entity(entity).remove::<GridCell>();
                    grid_events.send(GridEvent {
                        entity,
                        operation: GridOperation::Remove {
                            from: current_cell.0,
                        },
                    });
                }
            }
            _ => (),
        };
    }
}